diff --git a/spaces/0x90e/ESRGAN-MANGA/ESRGAN_plus/architecture.py b/spaces/0x90e/ESRGAN-MANGA/ESRGAN_plus/architecture.py
deleted file mode 100644
index 6ac437cfa8c1713eb060d1caa7ca70e1d2e9bb00..0000000000000000000000000000000000000000
--- a/spaces/0x90e/ESRGAN-MANGA/ESRGAN_plus/architecture.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import math
-import torch
-import torch.nn as nn
-import ESRGAN_plus.block as B
-
-
-class RRDB_Net(nn.Module):
-    def __init__(self, in_nc, out_nc, nf, nb, gc=32, upscale=4, norm_type=None, act_type='leakyrelu', \
-            mode='CNA', res_scale=1, upsample_mode='upconv'):
-        super(RRDB_Net, self).__init__()
-        n_upscale = int(math.log(upscale, 2))
-        if upscale == 3:
-            n_upscale = 1
-
-        fea_conv = B.conv_block(in_nc, nf, kernel_size=3, norm_type=None, act_type=None)
-        rb_blocks = [B.RRDB(nf, kernel_size=3, gc=32, stride=1, bias=True, pad_type='zero', \
-            norm_type=norm_type, act_type=act_type, mode='CNA') for _ in range(nb)]
-        LR_conv = B.conv_block(nf, nf, kernel_size=3, norm_type=norm_type, act_type=None, mode=mode)
-
-        if upsample_mode == 'upconv':
-            upsample_block = B.upconv_blcok
-        elif upsample_mode == 'pixelshuffle':
-            upsample_block = B.pixelshuffle_block
-        else:
-            raise NotImplementedError('upsample mode [%s] is not found' % upsample_mode)
-        if upscale == 3:
-            upsampler = upsample_block(nf, nf, 3, act_type=act_type)
-        else:
-            upsampler = [upsample_block(nf, nf, act_type=act_type) for _ in range(n_upscale)]
-        HR_conv0 = B.conv_block(nf, nf, kernel_size=3, norm_type=None, act_type=act_type)
-        HR_conv1 = B.conv_block(nf, out_nc, kernel_size=3, norm_type=None, act_type=None)
-
-        self.model = B.sequential(fea_conv, B.ShortcutBlock(B.sequential(*rb_blocks, LR_conv)),\
-            *upsampler, HR_conv0, HR_conv1)
-
-    def forward(self, x):
-        x = self.model(x)
-        return x
diff --git a/spaces/101-5/gpt4free/g4f/.v1/gui/streamlit_chat_app.py b/spaces/101-5/gpt4free/g4f/.v1/gui/streamlit_chat_app.py
deleted file mode 100644
index af3969e6fa682b0b237b0a7b8c228de83e7209ae..0000000000000000000000000000000000000000
--- a/spaces/101-5/gpt4free/g4f/.v1/gui/streamlit_chat_app.py
+++ /dev/null
@@ -1,156 +0,0 @@
-import atexit
-import Levenshtein
-import os
-import sys
-
-sys.path.append(os.path.join(os.path.dirname(__file__), os.path.pardir))
-
-import streamlit as st
-from streamlit_chat import message
-from query_methods import query, avail_query_methods
-import pickle
-
-conversations_file = "conversations.pkl"
-
-def load_conversations():
-    try:
-        with open(conversations_file, "rb") as f:
-            return pickle.load(f)
-    except FileNotFoundError:
-        return []
-    except EOFError:
-        return []
-
-
-def save_conversations(conversations, current_conversation):
-    updated = False
-    for idx, conversation in enumerate(conversations):
-        if conversation == current_conversation:
-            conversations[idx] = current_conversation
-            updated = True
-            break
-    if not updated:
-        conversations.append(current_conversation)
-
-    temp_conversations_file = "temp_" + conversations_file
-    with open(temp_conversations_file, "wb") as f:
-        pickle.dump(conversations, f)
-
-    os.replace(temp_conversations_file, conversations_file)
-
-def delete_conversation(conversations, current_conversation):
-    for idx, conversation in enumerate(conversations):
-        conversations[idx] = current_conversation
-        break
-    conversations.remove(current_conversation)
-
-    temp_conversations_file = "temp_" + conversations_file
-    with open(temp_conversations_file, "wb") as f:
-        pickle.dump(conversations, f)
-
-    os.replace(temp_conversations_file, conversations_file)
-
-def exit_handler():
-    print("Exiting, saving data...")
-    # Perform cleanup operations here, like saving data or closing open files.
-    save_conversations(st.session_state.conversations, st.session_state.current_conversation)
-
-
-# Register the exit_handler function to be called when the program is closing.
-atexit.register(exit_handler)
-
-st.header("Chat Placeholder")
-
-if 'conversations' not in st.session_state:
-    st.session_state['conversations'] = load_conversations()
-
-if 'input_text' not in st.session_state:
-    st.session_state['input_text'] = ''
-
-if 'selected_conversation' not in st.session_state:
-    st.session_state['selected_conversation'] = None
-
-if 'input_field_key' not in st.session_state:
-    st.session_state['input_field_key'] = 0
-
-if 'query_method' not in st.session_state:
-    st.session_state['query_method'] = query
-
-if 'search_query' not in st.session_state:
-    st.session_state['search_query'] = ''
-
-# Initialize new conversation
-if 'current_conversation' not in st.session_state or st.session_state['current_conversation'] is None:
-    st.session_state['current_conversation'] = {'user_inputs': [], 'generated_responses': []}
-
-input_placeholder = st.empty()
-user_input = input_placeholder.text_input(
-    'You:', value=st.session_state['input_text'], key=f'input_text_-1'#{st.session_state["input_field_key"]}
-)
-submit_button = st.button("Submit")
-
-if (user_input and user_input != st.session_state['input_text']) or submit_button:
-    output = query(user_input, st.session_state['query_method'])
-
-    escaped_output = output.encode('utf-8').decode('unicode-escape')
-
-    st.session_state['current_conversation']['user_inputs'].append(user_input)
-    st.session_state.current_conversation['generated_responses'].append(escaped_output)
-    save_conversations(st.session_state.conversations, st.session_state.current_conversation)
-    st.session_state['input_text'] = ''
-    st.session_state['input_field_key'] += 1  # Increment key value for new widget
-    user_input = input_placeholder.text_input(
-        'You:', value=st.session_state['input_text'], key=f'input_text_{st.session_state["input_field_key"]}'
-    )  # Clear the input field
-
-# Add a button to create a new conversation
-if st.sidebar.button("New Conversation"):
-    st.session_state['selected_conversation'] = None
-    st.session_state['current_conversation'] = {'user_inputs': [], 'generated_responses': []}
-    st.session_state['input_field_key'] += 1  # Increment key value for new widget
-    st.session_state['query_method'] = st.sidebar.selectbox("Select API:", options=avail_query_methods, index=0)
-
-# Proxy
-st.session_state['proxy'] = st.sidebar.text_input("Proxy: ")
-
-# Searchbar
-search_query = st.sidebar.text_input("Search Conversations:", value=st.session_state.get('search_query', ''), key='search')
-
-if search_query:
-    filtered_conversations = []
-    indices = []
-    for idx, conversation in enumerate(st.session_state.conversations):
-        if search_query in conversation['user_inputs'][0]:
-            filtered_conversations.append(conversation)
-            indices.append(idx)
-
-    filtered_conversations = list(zip(indices, filtered_conversations))
-    conversations = sorted(filtered_conversations, key=lambda x: Levenshtein.distance(search_query, x[1]['user_inputs'][0]))
-
-    sidebar_header = f"Search Results ({len(conversations)})"
-else:
-    conversations = st.session_state.conversations
-    sidebar_header = "Conversation History"
-
-# Sidebar
-st.sidebar.header(sidebar_header)
-sidebar_col1, sidebar_col2 = st.sidebar.columns([5,1])
-for idx, conversation in enumerate(conversations):
-    if sidebar_col1.button(f"Conversation {idx + 1}: {conversation['user_inputs'][0]}", key=f"sidebar_btn_{idx}"):
-        st.session_state['selected_conversation'] = idx
-        st.session_state['current_conversation'] = conversation
-    if sidebar_col2.button('🗑️', key=f"sidebar_btn_delete_{idx}"):
-        if st.session_state['selected_conversation'] == idx:
-            st.session_state['selected_conversation'] = None
-            st.session_state['current_conversation'] = {'user_inputs': [], 'generated_responses': []}
-        delete_conversation(conversations, conversation)
-        st.experimental_rerun()
-if st.session_state['selected_conversation'] is not None:
-    conversation_to_display = conversations[st.session_state['selected_conversation']]
-else:
-    conversation_to_display = st.session_state.current_conversation
-
-if conversation_to_display['generated_responses']:
-    for i in range(len(conversation_to_display['generated_responses']) - 1, -1, -1):
-        message(conversation_to_display["generated_responses"][i], key=f"display_generated_{i}")
-        message(conversation_to_display['user_inputs'][i], is_user=True, key=f"display_user_{i}")
\ No newline at end of file
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Fusion 360 2008 32 Bit __EXCLUSIVE__ Xforce Keygen.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Fusion 360 2008 32 Bit __EXCLUSIVE__ Xforce Keygen.md
deleted file mode 100644
index eedc826a9493fcf65c062f6b97cca98922c7195f..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Fusion 360 2008 32 Bit __EXCLUSIVE__ Xforce Keygen.md	
+++ /dev/null
@@ -1,40 +0,0 @@
-
-<h1>Fusion 360 2008 32 Bit Xforce Keygen: How to Activate Autodesk Products for Free</h1>
- <p>If you are looking for a powerful and versatile software for designing, modeling, and engineering, you might have heard of <strong>Fusion 360</strong>. Fusion 360 is a cloud-based CAD/CAM/CAE software that allows you to create, edit, and share your designs in various formats. It also integrates with other Autodesk products and services, such as AutoCAD, Inventor, Revit, Maya, and more.</p>
-<h2>Fusion 360 2008 32 Bit Xforce Keygen</h2><br /><p><b><b>Download File</b> &rarr;&rarr;&rarr; <a href="https://byltly.com/2uKxYI">https://byltly.com/2uKxYI</a></b></p><br /><br />
- <p>However, Fusion 360 is not a cheap software. It requires a monthly or yearly subscription fee that can range from $25 to $500 depending on your plan. If you want to use Fusion 360 without paying anything, you might be tempted to use a <strong>Xforce keygen</strong>. Xforce keygen is a crack tool that can generate activation codes for any Autodesk product. By using Xforce keygen, you can bypass the license verification process and activate Fusion 360 for free.</p>
- <p>But is it worth it? In this article, we will show you how to use Xforce keygen for Fusion 360 2008 32 bit, as well as the benefits and risks of doing so. We will also answer some frequently asked questions about Fusion 360 and Xforce keygen. Read on to find out more.</p>
- <h2>How to Download and Install Fusion 360 2008 32 Bit</h2>
- <p>Before you can use Xforce keygen for Fusion 360, you need to download and install the software first. Here are the steps to do so:</p> - Step 1: Download Fusion 360 2008 32 bit from the official website or a trusted source. You can find the download link here: . Make sure you choose the correct version for your operating system and system requirements. - Step 2: Run the setup file and follow the instructions. You may need to accept the terms and conditions, choose the installation location, and select the components you want to install. The installation process may take some time depending on your internet speed and computer performance. - Step 3: Choose the trial version or enter a serial number. If you have a valid serial number, you can enter it and activate Fusion 360. If not, you can choose the trial version and use it for 30 days. You can also sign in with your Autodesk account if you have one. <h2>How to Download and Use Xforce Keygen for Fusion 360 2008 32 Bit</h2>
- <p>Once you have installed Fusion 360, you can use Xforce keygen to activate it for free. Here are the steps to do so:</p>
- - Step 1: Download Xforce keygen from a reliable source. You can find many websites that offer Xforce keygen for various Autodesk products, but be careful of malware and viruses. One of the most popular sources is , but use it at your own risk. - Step 2: Disable your antivirus and internet connection. This is important because Xforce keygen is detected as a malicious program by most antivirus software and may be blocked or deleted. Also, disconnecting from the internet will prevent Autodesk from verifying your license online. - Step 3: Run Xforce keygen as administrator and click on "Patch". You will see a window that asks you to locate the file "xf-adsk2018_x86.exe" in your Fusion 360 installation folder. Usually, it is located in "C:\Program Files\Autodesk\Fusion 360\bin". Select the file and click on "Open". - Step 4: Copy the request code from Fusion 360 and paste it into Xforce keygen. To get the request code, open Fusion 360 and go to the "Help" menu. Click on "Register" and then on "Activate". You will see a screen that shows your serial number and a request code. Copy the request code and paste it into Xforce keygen where it says "Request". - Step 5: Click on "Generate" and copy the activation code from Xforce keygen. You will see a long string of letters and numbers that is your activation code. Copy it and go back to Fusion 360. - Step 6: Paste the activation code into Fusion 360 and click on "Next". You will see a message that says "Activation successful". Click on "Finish" and enjoy using Fusion 360 for free. <h2>How to Verify that Fusion 360 is Activated</h2>
- <p>To make sure that Fusion 360 is activated, you can do the following:</p>
- - Step 1: Open Fusion 360 and go to the "Help" menu. - Step 2: Click on "About Autodesk Fusion 360". - Step 3: Check the license status and expiration date. You should see that your license is valid until January 1, 2060, which means that you have activated Fusion 360 with Xforce keygen. <h2>Benefits of Using Fusion 360 with Xforce Keygen</h2>
- <p>By using Xforce keygen for Fusion 360, you can enjoy some benefits, such as:</p>
-<p></p>
- - Access to all features and updates of Fusion 360. You can use all the tools and functions of Fusion 360 without any limitations or restrictions. You can also download and install any updates or patches that are released by Autodesk. - No need to pay for a subscription or license. You can save money by not having to pay for a monthly or yearly fee to use Fusion 360. You can also avoid any renewal or cancellation issues that may arise with a subscription plan. - Ability to create, edit, and share designs in various formats. You can work on any type of design project with Fusion 360, from sketching to rendering to simulation. You can also export and import your designs in different formats, such as DWG, DXF, STL, OBJ, IGES, STEP, etc. - Compatibility with other Autodesk products and services. You can integrate your designs with other Autodesk software, such as AutoCAD, Inventor, Revit, Maya, etc. You can also access other Autodesk services, such as A360 cloud storage, Autodesk Gallery, Autodesk Education Community, etc. <h2>Risks and Drawbacks of Using Fusion 360 with Xforce Keygen</h2>
- <p>However, using Xforce keygen for Fusion 360 also comes with some risks and drawbacks, such as:</p>
- - Legal and ethical issues of using - Legal and ethical issues of using pirated software. By using Xforce keygen, you are violating the terms and conditions of Autodesk and infringing their intellectual property rights. You are also depriving them of their revenue and supporting software piracy. This can lead to legal consequences, such as fines, lawsuits, or even jail time. You are also acting unethically, as you are not respecting the work and effort of the software developers and creators. - Potential malware and virus infection from untrusted sources. Xforce keygen is not an official or authorized tool from Autodesk. It is created by hackers and crackers who may have malicious intentions. They may embed malware or viruses into the Xforce keygen file or the websites that offer it. This can compromise your computer security and privacy, as well as damage your files and data. - Possible errors and glitches in the software performance. Xforce keygen may not work properly with Fusion 360, especially if there are updates or patches from Autodesk. It may cause errors, crashes, or glitches in the software functionality or stability. It may also interfere with other programs or applications on your computer. - No technical support or customer service from Autodesk. If you encounter any problems or issues with Fusion 360, you cannot contact Autodesk for help or assistance. You are on your own, as Autodesk does not provide any support or service for pirated software. You may also miss out on some features or benefits that are only available for licensed users, such as online forums, tutorials, feedback, etc. <h2>Conclusion</h2>
- <p>Fusion 360 is a great software for design, modeling, and engineering. However, it is not a cheap software, and you may want to use Xforce keygen to activate it for free. Xforce keygen is a crack tool that can generate activation codes for any Autodesk product, including Fusion 360.</p>
- <p>In this article, we have shown you how to use Xforce keygen for Fusion 360 2008 32 bit, as well as the benefits and risks of doing so. We have also answered some frequently asked questions about Fusion 360 and Xforce keygen.</p>
- <p>Using Xforce keygen for Fusion 360 can give you access to all features and updates of the software without paying anything. However, it can also expose you to legal and ethical issues, malware and virus infection, errors and glitches, and no technical support or customer service.</p>
- <p>Ultimately, the decision is yours to make. We do not recommend or endorse using Xforce keygen for Fusion 360 or any other Autodesk product. We advise you to use the official website or a trusted source to download and install Fusion 360, and to pay for a subscription or license if you want to use it legally and ethically.</p>
- <p>If you found this article helpful, please share it with your friends and colleagues who may be interested in using Fusion 360 with Xforce keygen. If you have any questions or feedback, please leave a comment below. Thank you for reading.</p>
- <h2>FAQs</h2>
- <p>Here are some of the most common questions that people ask about Fusion 360 and Xforce keygen:</p>
- <h3>What is the difference between Fusion 360 and AutoCAD?</h3>
- <p>Fusion 360 and AutoCAD are both products from Autodesk that are used for design and engineering. However, they have some differences in their features and functions.</p>
- <p>AutoCAD is a 2D and 3D CAD software that is mainly used for drafting, documentation, and detailing. It has a wide range of tools and commands that allow you to create precise and accurate drawings and models.</p>
- <p>Fusion 360 is a cloud-based CAD/CAM/CAE software that is mainly used for design, modeling, and simulation. It has a more intuitive and user-friendly interface that allows you to create complex and organic shapes and forms. It also integrates with other Autodesk products and services, such as Inventor, Revit, Maya, etc.</p>
- <h3>Is Fusion 360 free for students and educators?</h3>
- <p>Yes, Fusion 360 is free for students and educators who are enrolled in or employed by a qualified educational institution. You can apply for a free educational license that will allow you to use Fusion 360 for non-commercial purposes for up to three years.</p>
- <p>To get a free educational license for Fusion 360, you need to create an Autodesk account with your educational email address. Then, you need to verify your eligibility by providing proof of your enrollment or employment status. After that, you can download and install Fusion 360 from the Autodesk Education Community website.</p>
- <h3>How can I update Fusion 360 after using Xforce keygen?</h3>
- <p>If you have used Xforce keygen to activate Fusion 360, you may not be able to update it automatically from the software itself. This is because Autodesk may detect - your license as invalid or expired and prevent you from updating. You may also lose your activation if you update Fusion 360 with Xforce keygen. - To update Fusion 360 after using Xforce keygen, you need to download the latest version of the software from the official website or a trusted source. Then, you need to uninstall the previous version of Fusion 360 and install the new one. After that, you need to use Xforce keygen again to activate the new version of Fusion 360. - Alternatively, you can use a patcher tool that can update Fusion 360 without affecting your activation. One of the most popular patchers is , but use it at your own risk. <h3>What are some alternatives to Xforce keygen for activating Autodesk products?</h3>
- <p>Xforce keygen is not the only crack tool that can activate Autodesk products. There are some other tools that can do the same thing, such as:</p>
- - : This is a universal keygen that can generate serial numbers and product keys for any Autodesk product. It also has a patch function that can modify the software files and bypass the license verification process. - : This is a patcher tool that can activate any Autodesk product by modifying the registry entries and the hosts file. It also has a backup and restore function that can save and restore your activation data. - : This is a loader tool that can activate any Autodesk product by injecting a DLL file into the software process. It also has a stealth mode that can hide the loader from detection. <p>However, these tools are also illegal and unethical, and they may have the same risks and drawbacks as Xforce keygen. We do not recommend or endorse using these tools for activating Autodesk products.</p>
- <h3>Where can I find more tutorials and resources for Fusion 360?</h3>
- <p>If you want to learn more about Fusion 360 and how to use it effectively, you can find many tutorials and resources online, such as:</p>
- - : This is the official website of Fusion 360, where you can find information, documentation, downloads, updates, forums, blogs, videos, webinars, events, and more. - : This is the official YouTube channel of Fusion 360, where you can find tutorials, tips, tricks, demos, showcases, live streams, and more. - : This is an online learning platform that offers courses and lessons on Fusion 360 and other Autodesk products. You can learn from experts and professionals at your own pace and level. - : This is an online community of Fusion 360 users, where you can share your designs, projects, questions, feedback, ideas, and more. You can also join groups, challenges, contests, and events. <p>These are some of the best sources for learning and improving your skills in Fusion 360. You can also search for other websites, blogs, podcasts, books, magazines, etc. that offer Fusion 360 tutorials and resources.</p> b2dd77e56b<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Cossacks Back To War __EXCLUSIVE__ Full Game Download.md b/spaces/1gistliPinn/ChatGPT4/Examples/Cossacks Back To War __EXCLUSIVE__ Full Game Download.md
deleted file mode 100644
index 00ece12c7fb7edd72ead4f01599b2189051d1711..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Cossacks Back To War __EXCLUSIVE__ Full Game Download.md	
+++ /dev/null
@@ -1,32 +0,0 @@
-<h2>cossacks back to war full game download</h2><br /><p><b><b>Download</b> &#9658;&#9658;&#9658; <a href="https://imgfil.com/2uy1Yf">https://imgfil.com/2uy1Yf</a></b></p><br /><br />
-
-ZOMBIE ATTACK (2014)
-
-NOVOLAND
-
-Jakob Keseberg
-
-As zombie hordes gather in occupied Europe, a powerful armada of airborne attack vehicles emerge to fight them. Heroes have to fight the undead from the skies or else face the devastating consequences.
-
-Jakob Keseberg grew up in Germany as a creative hobbyist with a passion for game development. He was already making video games at the age of 12, inspired by old arcade titles. Later he founded a company called Geek Bytes Studio, and to this day he continues to develop games.
-
-After finishing school he moved to Hamburg to work as a web developer. In 2011 Jakob Keseberg started studying to be a game developer and took his first steps in the game industry by creating the text adventure game "The Vampyricium" and the social game "Heroes of Shadow".
-
-ZOMBIE ATTACK (2014) (click the thumbnail for the official trailer)
-
-REAL-TIME STRATEGY WITH A HISTORICAL BACKGROUND
-
-The game puts the player in the shoes of a powerful airborne commander. The player takes control of ground and air forces to lead military operations on the continent of Europe. The player creates a strategic combination of military forces to defeat the invading zombie hordes.
-
-You have the opportunity to operate military operations at the strategic level of European politics, and the challenge of making history. The year is 1530, and Europe is about to plunge into chaos. Religiously motivated wars are spreading like wildfire across the continent, while great powers like Spain, France, and England are preparing to fight for the control of the new world. During this time, new kinds of weapons become available. It is your mission to determine who will survive, and to rule the world in their place.
-
-ZOMBIE ATTACK (2014) is a strategy game inspired by the German popular saying "Zombie attack!"
-
-TO THE ROOF OF EUROPE
-
-Europe has been invaded by hordes of undead, and the continent is experiencing its worst war. Now, armed with sword, pistol, and shotgun, you will lead the only force of its kind to make history. At the helm of your military force you will shape the destiny of the continent.
-
-In ZOMBIE ATTACK (2014) you will lead your forces to the roof of Europe. Through 4fefd39f24<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Fallout 3 Crack [BEST]ed Launcher 1.7.md b/spaces/1gistliPinn/ChatGPT4/Examples/Fallout 3 Crack [BEST]ed Launcher 1.7.md
deleted file mode 100644
index 8b4910fd04168bb9f87e165632d461578a937577..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Fallout 3 Crack [BEST]ed Launcher 1.7.md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<br />
-<p>bethesda's <em>fallout 4</em> is a completely overhauled version of the fallout engine. the title is based on the "true" fallout universe established by<em> fallout 3</em> and <em>fallout new vegas</em>, and the setting takes place in boston, which has been the center of civilization in the present and future. fallout 4 will include a full open world, with large towns, a government to rule, factions to choose from, and a dynamic main quest. the game's creators say it will also be the first entry in the series to feature a linear narrative.</p>
-<h2>fallout 3 cracked launcher 1.7</h2><br /><p><b><b>Download</b> ---> <a href="https://imgfil.com/2uy19L">https://imgfil.com/2uy19L</a></b></p><br /><br />
-<p>bethesda softworks also announced a new version of the game would be released on march 27, 2011. it was available on steam on march 29, 2011, and costs $15 for a pc edition or $40 for a game plus the director's cut. the director's cut consists of six new expansion packs, including <i>fallout: new california</i>, <i>fallout: new vegas</i>, <i>fallout: brotherhood of steel</i>, <i>fallout: brotherhood of steel - the pitt</i>, <i>fallout: brotherhood of steel - point lookout</i> and <i>fallout: brotherhood of steel - mothership zeta</i>, all free of drm and released on a weekly basis. <sup id=cite_ref-3 class=reference> [3] </sup> bethesda softworks also announced a new version of the game would be released on march 27, 2011. <sup id=cite_ref-4 class=reference> [4] </sup> the game also includes an enhanced version of the <i>companion app</i>, which allows players to access the in-game radio, map and quick-travel to an area with the iphone or ipod touch. the game was also re-released as a part of a bundle pack with the first two expansion packs, which included the game and the first two expansion packs, which included the game and the first two expansion packs. </p> 899543212b<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download Free Games for MacBook Air and Experience the Thrill of Gaming.md b/spaces/1phancelerku/anime-remove-background/Download Free Games for MacBook Air and Experience the Thrill of Gaming.md
deleted file mode 100644
index 9fba39c1d1846127f65fab6b66a12b65421dd1c4..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download Free Games for MacBook Air and Experience the Thrill of Gaming.md	
+++ /dev/null
@@ -1,140 +0,0 @@
-<br />
-<h1>How to Download Free Games for MacBook Air</h1>
-<p>If you are a MacBook Air user, you might be wondering how to download free games for your device. After all, gaming is not only fun but also a great way to relax and unwind. However, finding free games for Mac can be challenging, as not all games are compatible with macOS or optimized for the MacBook Air's performance. In this article, we will show you how to download free games for MacBook Air using different methods, such as Steam, the App Store, and iPad games. We will also recommend some of the best free games that you can enjoy on your MacBook Air.</p>
- <h2>Install Steam on Mac</h2>
-<p>Steam is one of the most popular online gaming platforms for PC and Mac users. It offers thousands of games across various genres, many of which are free to play or have free demos. To use Steam on your Mac, you need to install the Steam app first. Here's how:</p>
-<h2>download free games for macbook air</h2><br /><p><b><b>DOWNLOAD</b> &#10027;&#10027;&#10027; <a href="https://jinyurl.com/2uNNPs">https://jinyurl.com/2uNNPs</a></b></p><br /><br />
-<ul>
-<li>Go to <a href="(^1^)">steampowered.com</a> in your browser.</li>
-<li>Click Install Steam at the top right of the webpage.</li>
-<li>Choose Install Steam.</li>
-<li>Next, click the show downloads button.</li>
-<li>Double-click on steam.dmg to launch the installer.</li>
-<li>Drag Steam into the Applications folder.</li>
-<li>Exit the window.</li>
-</ul>
- <h2>Download a Steam game on Mac</h2>
-<p>Once you have installed Steam on your Mac, you can browse and download games from its library. To download a Steam game on your Mac, follow these steps:</p>
-<ul>
-<li>Launch Steam from the Applications folder.</li>
-<li>Choose Open, if applicable.</li>
-<li>Wait for Steam to update.</li>
-<li>Create a new account or log in into an existing account if you have one.</li>
-<li>Go to Store.</li>
-<li>Browse or search for the game that you want to download. Make sure it has an Apple logo next to it, which means it is compatible with Mac.</li>
-<li>Click on the title you want to download.</li>
-<li>Choose Add to Cart.</li>
-<li>Click Purchase for myself.</li>
-<li>Select your payment method. You can also use your Steam Wallet balance if you have any.</li>
-<li>Fill out your payment information.</li>
-<li>Click Continue.</li>
-<li>Click the checkbox to agree to the terms.</li>
-<li>Click Purchase.</li>
-</ul>
-<p>From here, your game will begin to download, and you can start playing as soon as it's done. You can also manage your downloads and library from the Library tab in Steam.</p>
- <h2>Download apps from the App Store on Mac</h2>
-<p>If you prefer not to use Steam or want to find more games that are designed for macOS, you can use the App Store on your Mac. The App Store has a wide selection of apps and games for your Mac, some of which are free or have free trials. To download apps from the App Store on your Mac, follow these steps:</p>
-<ul>
-<li>Open the App Store from the Dock or the Applications folder.</li>
-<li>Sign in with your Apple ID and password if you haven't already.</li>
-<li>Go to Games.</li>
-<li>Browse or search for the game that you want to download. You can also filter by categories, ratings, prices, and more.</li>
-<li>Click on the game that you want to download.</li>
-<li>Click Get if the game is free, or click the price if it is paid.</li>
-<li>Enter your Apple ID password or use Touch ID if prompted.</li>
-<li>Wait for the game to download and install on your Mac.</li>
-</ul>
-<p>You can find your downloaded games in the Launchpad or the Applications folder. You can also manage your purchases and updates from the App Store.</p>
- <h2>Download iPad games on Mac with Apple Silicon</h2>
-<p>If you have a MacBook Air with an Apple Silicon processor, such as the M1 chip, you can also download and play iPad games on your Mac. This is because Apple Silicon Macs can run iOS apps natively, without any emulation or compatibility issues. However, not all iPad games are available for Mac, as some developers may choose to opt out of this feature. To download iPad games on your Mac with Apple Silicon, follow these steps:</p>
-<p>download free games for macbook air 2023<br />
-download free games for macbook air offline<br />
-download free games for macbook air without app store<br />
-download free games for macbook air full version<br />
-download free games for macbook air no internet<br />
-download free games for macbook air from steam<br />
-download free games for macbook air adventure<br />
-download free games for macbook air racing<br />
-download free games for macbook air puzzle<br />
-download free games for macbook air strategy<br />
-download free games for macbook air simulation<br />
-download free games for macbook air action<br />
-download free games for macbook air horror<br />
-download free games for macbook air rpg<br />
-download free games for macbook air multiplayer<br />
-download free games for macbook air shooting<br />
-download free games for macbook air sports<br />
-download free games for macbook air educational<br />
-download free games for macbook air casual<br />
-download free games for macbook air hidden object<br />
-download free games for macbook air arcade<br />
-download free games for macbook air platformer<br />
-download free games for macbook air sandbox<br />
-download free games for macbook air survival<br />
-download free games for macbook air tycoon<br />
-download free games for macbook air card<br />
-download free games for macbook air board<br />
-download free games for macbook air trivia<br />
-download free games for macbook air word<br />
-download free games for macbook air match 3<br />
-download free games for macbook air solitaire<br />
-download free games for macbook air mahjong<br />
-download free games for macbook air sudoku<br />
-download free games for macbook air crossword<br />
-download free games for macbook air chess<br />
-download free games for macbook air checkers<br />
-download free games for macbook air backgammon<br />
-download free games for macbook air minesweeper<br />
-download free games for macbook air snake<br />
-download free games for macbook air tetris<br />
-download free games for macbook air pacman<br />
-download free games for macbook air pinball<br />
-download free games for macbook air breakout<br />
-download free games for macbook air space invaders<br />
-download free games for macbook air frogger<br />
-download free games for macbook air asteroids<br />
-download free games for macbook air pong<br />
-download free games for macbook air galaga<br />
-download free games for macbook air donkey kong</p>
-<ul>
-<li>Open the App Store from the Dock or the Applications folder.</li>
-<li>Sign in with your Apple ID and password if you haven't already.</li>
-<li>Go to Games.</li>
-<li>Click on iPhone & iPad Apps in the sidebar.</li>
-<li>Browse or search for the game that you want to download. You can also filter by categories, ratings, prices, and more.</li>
-<li>Click on the game that you want to download.</li>
-<li>Click Get if the game is free, or click the price if it is paid.</li>
-<li>Enter your Apple ID password or use Touch ID if prompted.</li>
-<li>Wait for the game to download and install on your Mac.</li>
-</ul>
-<p>You can find your downloaded iPad games in the Launchpad or the Applications folder. You can also manage your purchases and updates from the App Store.</p>
- <h2>Best free games for MacBook Air</h2>
-<p>Now that you know how to download free games for MacBook Air using different methods, you might be wondering what are some of the best free games that you can play on your device. Here are some of our recommendations:</p>
-<ol>
-<li><strong>Dota 2</strong>: Dota 2 is one of the most popular and competitive multiplayer online battle arena (MOBA) games in the world. It features hundreds of heroes, each with their own unique abilities and playstyles, and a variety of game modes and maps. You can team up with friends or strangers and fight against other players in matches that can last from 20 minutes to over an hour. Dota 2 is free to play on Steam, but you can also buy cosmetic items and battle passes to enhance your experience. <a href="">Download Dota 2 here</a>.</li>
-<li><strong>Among Us</strong>: Among Us is a social deduction game that has taken the internet by storm. It is set in a spaceship where one or more impostors are trying to sabotage and kill the crewmates, while the crewmates are trying to complete tasks and find out who the impostors are. You can play online with up to 10 players, or locally with up to 4 players. Among Us is free to play on iOS devices, but you can also buy it for $4.99 on Steam or $6.99 on the App Store for Mac. <a href="">Download Among Us here</a>.</li>
-<li><strong>Fallout Shelter</strong>: Fallout Shelter is a simulation game based on the Fallout series. It puts you in charge of a vault, where you have to build rooms, assign dwellers, manage resources, and protect your vault from disasters and enemies. You can also explore the wasteland, send dwellers on quests, and collect weapons and outfits. Fallout Shelter is free to play on iOS devices, but you can also buy it for $9.99 on Steam or $14.99 on the App Store for Mac. <a href="">Download Fallout Shelter here</a>.</li>
-</ol>
- <h2>Conclusion</h2>
-<p>In this article, we have shown you how to download free games for MacBook Air using different methods, such as Steam, the App Store, and iPad games. We have also recommended some of the best free games that you can play on your MacBook Air, such as Dota 2, Among Us, and Fallout Shelter. We hope you have found this article helpful and informative, and that you have fun playing these games on your MacBook Air. Here are some FAQs that you might have about downloading free games for MacBook Air.</p>
- <h2>FAQs</h2>
-<dl>
-<dt>How do I uninstall a game from my MacBook Air?</dt>
-<dd>To uninstall a game from your MacBook Air, you can either drag it to the Trash from the Applications folder, or use an uninstaller app that can remove all the associated files and folders. You can also delete a game from Steam or the App Store by right-clicking on it and choosing Delete or Move to Trash.</dd>
-<dt>How do I update a game on my MacBook Air?</dt>
-<dd>To update a game on your MacBook Air, you can either check for updates manually from the game's menu or settings, or enable automatic updates from Steam or the App Store. You can also check for updates from the Updates tab in the App Store, or from the Downloads tab in Steam.</dd>
-<dt>How do I optimize a game's performance on my MacBook Air?</dt>
-<dd>To optimize a game's performance on your MacBook Air, you can try some of the following tips: <ul>
-<li>Close any unnecessary apps or tabs that are running in the background.</li>
-<li>Adjust the game's graphics settings to lower the resolution, quality, or effects.</li>
-<li>Use an external monitor, keyboard, and mouse for better gaming experience.</li>
-<li>Keep your MacBook Air cool and ventilated by using a cooling pad or fan.</li>
-<li>Update your macOS and drivers to the latest versions.</li>
-</ul></dd>
-<dt>How do I play online games on my MacBook Air?</dt>
-<dd>To play online games on your MacBook Air, you need to have a stable and fast internet connection, preferably wired or Wi-Fi. You also need to have an account for the online gaming platform or service that you are using, such as Steam, Origin, Epic Games, etc. You may also need to pay a subscription fee or buy in-game currency or items for some online games.</dd>
-<dt>How do I play Windows games on my MacBook Air?</dt>
-<dd>To play Windows games on your MacBook Air, you need to use a software that can run Windows applications on Mac, such as Boot Camp, Parallels Desktop, Wine, or Crossover. However, not all Windows games are compatible with Mac, and some may have performance issues or bugs. You also need to have a valid license for Windows and enough disk space and memory for the installation.</dd>
-</dl></p> 197e85843d<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/1toTree/lora_test/ppdiffusers/pipelines/stable_diffusion/pipeline_cycle_diffusion.py b/spaces/1toTree/lora_test/ppdiffusers/pipelines/stable_diffusion/pipeline_cycle_diffusion.py
deleted file mode 100644
index a352efdc98e0aad330fca4f490a0616e5175c873..0000000000000000000000000000000000000000
--- a/spaces/1toTree/lora_test/ppdiffusers/pipelines/stable_diffusion/pipeline_cycle_diffusion.py
+++ /dev/null
@@ -1,631 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. 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 inspect
-from typing import Callable, List, Optional, Union
-
-import numpy as np
-import paddle
-import PIL
-from packaging import version
-
-from paddlenlp.transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
-
-from ...configuration_utils import FrozenDict
-from ...models import AutoencoderKL, UNet2DConditionModel
-from ...pipeline_utils import DiffusionPipeline
-from ...schedulers import DDIMScheduler
-from ...utils import PIL_INTERPOLATION, deprecate, logging
-from . import StableDiffusionPipelineOutput
-from .safety_checker import StableDiffusionSafetyChecker
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.preprocess
-def preprocess(image):
-    if isinstance(image, paddle.Tensor):
-        return image
-    elif isinstance(image, PIL.Image.Image):
-        image = [image]
-
-    if isinstance(image[0], PIL.Image.Image):
-        w, h = image[0].size
-        w, h = map(lambda x: x - x % 32, (w, h))  # resize to integer multiple of 32
-
-        image = [np.array(i.resize((w, h), resample=PIL_INTERPOLATION["lanczos"]))[None, :] for i in image]
-        image = np.concatenate(image, axis=0)
-        image = np.array(image).astype(np.float32) / 255.0
-        image = image.transpose(0, 3, 1, 2)
-        image = 2.0 * image - 1.0
-        image = paddle.to_tensor(image)
-    elif isinstance(image[0], paddle.Tensor):
-        image = paddle.concat(image, axis=0)
-    return image
-
-
-def posterior_sample(scheduler, latents, timestep, clean_latents, generator, eta):
-    # 1. get previous step value (=t-1)
-    prev_timestep = timestep - scheduler.config.num_train_timesteps // scheduler.num_inference_steps
-
-    if prev_timestep <= 0:
-        return clean_latents
-
-    # 2. compute alphas, betas
-    alpha_prod_t = scheduler.alphas_cumprod[timestep]
-    alpha_prod_t_prev = (
-        scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else scheduler.final_alpha_cumprod
-    )
-
-    variance = scheduler._get_variance(timestep, prev_timestep)
-    std_dev_t = eta * variance ** (0.5)
-
-    # direction pointing to x_t
-    e_t = (latents - alpha_prod_t ** (0.5) * clean_latents) / (1 - alpha_prod_t) ** (0.5)
-    dir_xt = (1.0 - alpha_prod_t_prev - std_dev_t**2) ** (0.5) * e_t
-    noise = std_dev_t * paddle.randn(clean_latents.shape, dtype=clean_latents.dtype, generator=generator)
-    prev_latents = alpha_prod_t_prev ** (0.5) * clean_latents + dir_xt + noise
-
-    return prev_latents
-
-
-def compute_noise(scheduler, prev_latents, latents, timestep, noise_pred, eta):
-    # 1. get previous step value (=t-1)
-    prev_timestep = timestep - scheduler.config.num_train_timesteps // scheduler.num_inference_steps
-
-    # 2. compute alphas, betas
-    alpha_prod_t = scheduler.alphas_cumprod[timestep]
-    alpha_prod_t_prev = (
-        scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else scheduler.final_alpha_cumprod
-    )
-
-    beta_prod_t = 1 - alpha_prod_t
-
-    # 3. compute predicted original sample from predicted noise also called
-    # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
-    pred_original_sample = (latents - beta_prod_t ** (0.5) * noise_pred) / alpha_prod_t ** (0.5)
-
-    # 4. Clip "predicted x_0"
-    if scheduler.config.clip_sample:
-        pred_original_sample = pred_original_sample.clip(-1, 1)
-
-    # 5. compute variance: "sigma_t(η)" -> see formula (16)
-    # σ_t = sqrt((1 − α_t−1)/(1 − α_t)) * sqrt(1 − α_t/α_t−1)
-    variance = scheduler._get_variance(timestep, prev_timestep)
-    std_dev_t = eta * variance ** (0.5)
-
-    # 6. compute "direction pointing to x_t" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
-    pred_sample_direction = (1 - alpha_prod_t_prev - std_dev_t**2) ** (0.5) * noise_pred
-
-    noise = (prev_latents - (alpha_prod_t_prev ** (0.5) * pred_original_sample + pred_sample_direction)) / (
-        variance ** (0.5) * eta
-    )
-    return noise
-
-
-class CycleDiffusionPipeline(DiffusionPipeline):
-    r"""
-    Pipeline for text-guided image to image generation using Stable Diffusion.
-
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
-    library implements for all the pipelines (such as downloading or saving, running on a particular xxxx, etc.)
-
-    Args:
-        vae ([`AutoencoderKL`]):
-            Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
-        text_encoder ([`CLIPTextModel`]):
-            Frozen text-encoder. Stable Diffusion uses the text portion of
-            [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically
-            the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant.
-        tokenizer (`CLIPTokenizer`):
-            Tokenizer of class
-            [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
-        unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the encoded image latents.
-        scheduler ([`SchedulerMixin`]):
-            A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
-            [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
-        safety_checker ([`StableDiffusionSafetyChecker`]):
-            Classification module that estimates whether generated images could be considered offensive or harmful.
-            Please, refer to the [model card](https://huggingface.co/CompVis/stable-diffusion-v1-4) for details.
-        feature_extractor ([`CLIPFeatureExtractor`]):
-            Model that extracts features from generated images to be used as inputs for the `safety_checker`.
-    """
-    _optional_components = ["safety_checker", "feature_extractor"]
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: CLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        unet: UNet2DConditionModel,
-        scheduler: DDIMScheduler,
-        safety_checker: StableDiffusionSafetyChecker,
-        feature_extractor: CLIPFeatureExtractor,
-        requires_safety_checker: bool = True,
-    ):
-        super().__init__()
-
-        if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1:
-            deprecation_message = (
-                f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
-                f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
-                "to update the config accordingly as leaving `steps_offset` might led to incorrect results"
-                " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
-                " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
-                " file"
-            )
-            deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(scheduler.config)
-            new_config["steps_offset"] = 1
-            scheduler._internal_dict = FrozenDict(new_config)
-
-        if safety_checker is None and requires_safety_checker:
-            logger.warning(
-                f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
-                " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"
-                " results in services or applications open to the public. PaddleNLP team, diffusers team and Hugging Face"
-                " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
-                " it only for use-cases that involve analyzing network behavior or auditing its results. For more"
-                " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."
-            )
-        if safety_checker is not None and feature_extractor is None:
-            raise ValueError(
-                "Make sure to define a feature extractor when loading {self.__class__} if you want to use the safety"
-                " checker. If you do not want to use the safety checker, you can pass `'safety_checker=None'` instead."
-            )
-        is_unet_version_less_0_9_0 = hasattr(unet.config, "_ppdiffusers_version") and version.parse(
-            version.parse(unet.config._ppdiffusers_version).base_version
-        ) < version.parse("0.9.0.dev0")
-        is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
-        if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
-            deprecation_message = (
-                "The configuration file of the unet has set the default `sample_size` to smaller than"
-                " 64 which seems highly unlikely. If your checkpoint is a fine-tuned version of any of the"
-                " following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
-                " CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
-                " \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
-                " configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
-                " in the config might lead to incorrect results in future versions. If you have downloaded this"
-                " checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for"
-                " the `unet/config.json` file"
-            )
-            deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(unet.config)
-            new_config["sample_size"] = 64
-            unet._internal_dict = FrozenDict(new_config)
-
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=feature_extractor,
-        )
-
-        self.register_to_config(requires_safety_checker=requires_safety_checker)
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._encode_prompt
-    def _encode_prompt(self, prompt, num_images_per_prompt, do_classifier_free_guidance, negative_prompt):
-        r"""
-        Encodes the prompt into text encoder hidden states.
-
-        Args:
-            prompt (`str` or `list(int)`):
-                prompt to be encoded
-            num_images_per_prompt (`int`):
-                number of images that should be generated per prompt
-            do_classifier_free_guidance (`bool`):
-                whether to use classifier free guidance or not
-            negative_prompt (`str` or `List[str]`):
-                The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
-                if `guidance_scale` is less than `1`).
-        """
-        batch_size = len(prompt) if isinstance(prompt, list) else 1
-
-        text_inputs = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=self.tokenizer.model_max_length,
-            truncation=True,
-            return_tensors="pd",
-        )
-        text_input_ids = text_inputs.input_ids
-        untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pd").input_ids
-
-        if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not paddle.equal_all(
-            text_input_ids, untruncated_ids
-        ):
-            removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1])
-            logger.warning(
-                "The following part of your input was truncated because CLIP can only handle sequences up to"
-                f" {self.tokenizer.model_max_length} tokens: {removed_text}"
-            )
-
-        if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-            attention_mask = text_inputs.attention_mask
-        else:
-            attention_mask = None
-
-        text_embeddings = self.text_encoder(
-            text_input_ids,
-            attention_mask=attention_mask,
-        )
-        text_embeddings = text_embeddings[0]
-
-        # duplicate text embeddings for each generation per prompt, using mps friendly method
-        bs_embed, seq_len, _ = text_embeddings.shape
-        text_embeddings = text_embeddings.tile([1, num_images_per_prompt, 1])
-        text_embeddings = text_embeddings.reshape([bs_embed * num_images_per_prompt, seq_len, -1])
-
-        # get unconditional embeddings for classifier free guidance
-        if do_classifier_free_guidance:
-            uncond_tokens: List[str]
-            if negative_prompt is None:
-                uncond_tokens = [""] * batch_size
-            elif type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            elif isinstance(negative_prompt, str):
-                uncond_tokens = [negative_prompt]
-            elif batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-            else:
-                uncond_tokens = negative_prompt
-
-            max_length = text_input_ids.shape[-1]
-            uncond_input = self.tokenizer(
-                uncond_tokens,
-                padding="max_length",
-                max_length=max_length,
-                truncation=True,
-                return_tensors="pd",
-            )
-
-            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-                attention_mask = uncond_input.attention_mask
-            else:
-                attention_mask = None
-
-            uncond_embeddings = self.text_encoder(
-                uncond_input.input_ids,
-                attention_mask=attention_mask,
-            )
-            uncond_embeddings = uncond_embeddings[0]
-
-            # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
-            seq_len = uncond_embeddings.shape[1]
-            uncond_embeddings = uncond_embeddings.tile([1, num_images_per_prompt, 1])
-            uncond_embeddings = uncond_embeddings.reshape([batch_size * num_images_per_prompt, seq_len, -1])
-
-            # For classifier free guidance, we need to do two forward passes.
-            # Here we concatenate the unconditional and text embeddings into a single batch
-            # to avoid doing two forward passes
-            text_embeddings = paddle.concat([uncond_embeddings, text_embeddings])
-
-        return text_embeddings
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline.check_inputs
-    def check_inputs(self, prompt, strength, callback_steps):
-        if not isinstance(prompt, str) and not isinstance(prompt, list):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        if strength < 0 or strength > 1:
-            raise ValueError(f"The value of strength should in [1.0, 1.0] but is {strength}")
-
-        if (callback_steps is None) or (
-            callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
-        ):
-            raise ValueError(
-                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
-                f" {type(callback_steps)}."
-            )
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs
-    def prepare_extra_step_kwargs(self, generator, eta):
-        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
-        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
-        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
-        # and should be between [0, 1]
-
-        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        extra_step_kwargs = {}
-        if accepts_eta:
-            extra_step_kwargs["eta"] = eta
-
-        # check if the scheduler accepts generator
-        accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        if accepts_generator:
-            extra_step_kwargs["generator"] = generator
-        return extra_step_kwargs
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.run_safety_checker
-    def run_safety_checker(self, image, dtype):
-        if self.safety_checker is not None:
-            safety_checker_input = self.feature_extractor(self.numpy_to_pil(image), return_tensors="pd")
-            image, has_nsfw_concept = self.safety_checker(
-                images=image, clip_input=safety_checker_input.pixel_values.cast(dtype)
-            )
-        else:
-            has_nsfw_concept = None
-        return image, has_nsfw_concept
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.decode_latents
-    def decode_latents(self, latents):
-        latents = 1 / 0.18215 * latents
-        image = self.vae.decode(latents).sample
-        image = (image / 2 + 0.5).clip(0, 1)
-        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16
-        image = image.transpose([0, 2, 3, 1]).cast("float32").numpy()
-        return image
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline.get_timesteps
-    def get_timesteps(self, num_inference_steps, strength):
-        # get the original timestep using init_timestep
-        init_timestep = min(int(num_inference_steps * strength), num_inference_steps)
-
-        t_start = max(num_inference_steps - init_timestep, 0)
-        timesteps = self.scheduler.timesteps[t_start:]
-
-        return timesteps, num_inference_steps - t_start
-
-    def prepare_latents(self, image, timestep, batch_size, num_images_per_prompt, dtype, generator=None):
-        image = image.cast(dtype=dtype)
-
-        batch_size = image.shape[0]
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-
-        if isinstance(generator, list):
-            init_latents = [
-                self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(batch_size)
-            ]
-            init_latents = paddle.concat(init_latents, axis=0)
-        else:
-            init_latents = self.vae.encode(image).latent_dist.sample(generator)
-        init_latents = 0.18215 * init_latents
-
-        if batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] == 0:
-            # expand init_latents for batch_size
-            deprecation_message = (
-                f"You have passed {batch_size} text prompts (`prompt`), but only {init_latents.shape[0]} initial"
-                " images (`image`). Initial images are now duplicating to match the number of text prompts. Note"
-                " that this behavior is deprecated and will be removed in a version 1.0.0. Please make sure to update"
-                " your script to pass as many initial images as text prompts to suppress this warning."
-            )
-            deprecate("len(prompt) != len(image)", "1.0.0", deprecation_message, standard_warn=False)
-            additional_image_per_prompt = batch_size // init_latents.shape[0]
-            init_latents = paddle.concat([init_latents] * additional_image_per_prompt * num_images_per_prompt, axis=0)
-        elif batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] != 0:
-            raise ValueError(
-                f"Cannot duplicate `image` of batch size {init_latents.shape[0]} to {batch_size} text prompts."
-            )
-        else:
-            init_latents = paddle.concat([init_latents] * num_images_per_prompt, axis=0)
-
-        # add noise to latents using the timestep
-        shape = init_latents.shape
-        if isinstance(generator, list):
-            shape = [
-                1,
-            ] + shape[1:]
-            noise = [paddle.randn(shape, generator=generator[i], dtype=dtype) for i in range(batch_size)]
-            noise = paddle.concat(noise, axis=0)
-        else:
-            noise = paddle.randn(shape, generator=generator, dtype=dtype)
-
-        # get latents
-        clean_latents = init_latents
-        init_latents = self.scheduler.add_noise(init_latents, noise, timestep)
-        latents = init_latents
-
-        return latents, clean_latents
-
-    @paddle.no_grad()
-    def __call__(
-        self,
-        prompt: Union[str, List[str]],
-        source_prompt: Union[str, List[str]],
-        image: Union[paddle.Tensor, PIL.Image.Image] = None,
-        strength: float = 0.8,
-        num_inference_steps: Optional[int] = 50,
-        guidance_scale: Optional[float] = 7.5,
-        source_guidance_scale: Optional[float] = 1,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: Optional[float] = 0.1,
-        generator: Optional[Union[paddle.Generator, List[paddle.Generator]]] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, paddle.Tensor], None]] = None,
-        callback_steps: Optional[int] = 1,
-    ):
-        r"""
-        Function invoked when calling the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`):
-                The prompt or prompts to guide the image generation.
-            image (`paddle.Tensor` or `PIL.Image.Image`):
-                `Image`, or tensor representing an image batch, that will be used as the starting point for the
-                process.
-            strength (`float`, *optional*, defaults to 0.8):
-                Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1.
-                `image` will be used as a starting point, adding more noise to it the larger the `strength`. The
-                number of denoising steps depends on the amount of noise initially added. When `strength` is 1, added
-                noise will be maximum and the denoising process will run for the full number of iterations specified in
-                `num_inference_steps`. A value of 1, therefore, essentially ignores `image`.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference. This parameter will be modulated by `strength`.
-            guidance_scale (`float`, *optional*, defaults to 7.5):
-                Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
-                `guidance_scale` is defined as `w` of equation 2. of [Imagen
-                Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
-                1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
-                usually at the expense of lower image quality.
-            source_guidance_scale (`float`, *optional*, defaults to 1):
-                Guidance scale for the source prompt. This is useful to control the amount of influence the source
-                prompt for encoding.
-            num_images_per_prompt (`int`, *optional*, defaults to 1):
-                The number of images to generate per prompt.
-            eta (`float`, *optional*, defaults to 0.1):
-                Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to
-                [`schedulers.DDIMScheduler`], will be ignored for others.
-            generator (`paddle.Generator`, *optional*):
-                One or a list of paddle generator(s) to make generation deterministic.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generate image. Choose between
-                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
-                plain tuple.
-            callback (`Callable`, *optional*):
-                A function that will be called every `callback_steps` steps during inference. The function will be
-                called with the following arguments: `callback(step: int, timestep: int, latents: paddle.Tensor)`.
-            callback_steps (`int`, *optional*, defaults to 1):
-                The frequency at which the `callback` function will be called. If not specified, the callback will be
-                called at every step.
-
-        Returns:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple.
-            When returning a tuple, the first element is a list with the generated images, and the second element is a
-            list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work"
-            (nsfw) content, according to the `safety_checker`.
-        """
-        # 1. Check inputs
-        self.check_inputs(prompt, strength, callback_steps)
-
-        # 2. Define call parameters
-        batch_size = 1 if isinstance(prompt, str) else len(prompt)
-        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-        # corresponds to doing no classifier free guidance.
-        do_classifier_free_guidance = guidance_scale > 1.0
-
-        # 3. Encode input prompt
-        text_embeddings = self._encode_prompt(prompt, num_images_per_prompt, do_classifier_free_guidance, None)
-        source_text_embeddings = self._encode_prompt(
-            source_prompt, num_images_per_prompt, do_classifier_free_guidance, None
-        )
-
-        # 4. Preprocess image
-        image = preprocess(image)
-
-        # 5. Prepare timesteps
-        self.scheduler.set_timesteps(num_inference_steps)
-        timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength)
-        latent_timestep = timesteps[:1].tile([batch_size * num_images_per_prompt])
-
-        # 6. Prepare latent variables
-        latents, clean_latents = self.prepare_latents(
-            image, latent_timestep, batch_size, num_images_per_prompt, text_embeddings.dtype, generator
-        )
-        source_latents = latents
-
-        # 7. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
-        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-        generator = extra_step_kwargs.pop("generator", None)
-
-        # 8. Denoising loop
-        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            for i, t in enumerate(timesteps):
-                # expand the latents if we are doing classifier free guidance
-                latent_model_input = paddle.concat([latents] * 2)
-                source_latent_model_input = paddle.concat([source_latents] * 2)
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-                source_latent_model_input = self.scheduler.scale_model_input(source_latent_model_input, t)
-
-                # predict the noise residual
-                concat_latent_model_input = paddle.stack(
-                    [
-                        source_latent_model_input[0],
-                        latent_model_input[0],
-                        source_latent_model_input[1],
-                        latent_model_input[1],
-                    ],
-                    axis=0,
-                )
-                concat_text_embeddings = paddle.stack(
-                    [
-                        source_text_embeddings[0],
-                        text_embeddings[0],
-                        source_text_embeddings[1],
-                        text_embeddings[1],
-                    ],
-                    axis=0,
-                )
-                concat_noise_pred = self.unet(
-                    concat_latent_model_input, t, encoder_hidden_states=concat_text_embeddings
-                ).sample
-
-                # perform guidance
-                (
-                    source_noise_pred_uncond,
-                    noise_pred_uncond,
-                    source_noise_pred_text,
-                    noise_pred_text,
-                ) = concat_noise_pred.chunk(4, axis=0)
-                noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-                source_noise_pred = source_noise_pred_uncond + source_guidance_scale * (
-                    source_noise_pred_text - source_noise_pred_uncond
-                )
-
-                # Sample source_latents from the posterior distribution.
-                prev_source_latents = posterior_sample(
-                    self.scheduler, source_latents, t, clean_latents, generator=generator, **extra_step_kwargs
-                )
-                # Compute noise.
-                noise = compute_noise(
-                    self.scheduler, prev_source_latents, source_latents, t, source_noise_pred, **extra_step_kwargs
-                )
-                source_latents = prev_source_latents
-
-                # compute the previous noisy sample x_t -> x_t-1
-                latents = self.scheduler.step(
-                    noise_pred, t, latents, variance_noise=noise, **extra_step_kwargs
-                ).prev_sample
-
-                # call the callback, if provided
-                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
-                    progress_bar.update()
-                    if callback is not None and i % callback_steps == 0:
-                        callback(i, t, latents)
-
-        # 9. Post-processing
-        image = self.decode_latents(latents)
-
-        # 10. Run safety checker
-        image, has_nsfw_concept = self.run_safety_checker(image, text_embeddings.dtype)
-
-        # 11. Convert to PIL
-        if output_type == "pil":
-            image = self.numpy_to_pil(image)
-
-        if not return_dict:
-            return (image, has_nsfw_concept)
-
-        return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)
diff --git a/spaces/7thHeaven/ochyai_food/README.md b/spaces/7thHeaven/ochyai_food/README.md
deleted file mode 100644
index f16c0c5cc9994b0e5e8cc517ed40c523be62278c..0000000000000000000000000000000000000000
--- a/spaces/7thHeaven/ochyai_food/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: ochyai_food
-emoji: 🍛
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-sdk_version: 3.19.1
-app_file: app.py
-pinned: false
-duplicated_from: ochyai/ochyai_food
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/801artistry/RVC801/infer/lib/infer_pack/onnx_inference.py b/spaces/801artistry/RVC801/infer/lib/infer_pack/onnx_inference.py
deleted file mode 100644
index 6633659fc83b19d82611d3c9cc840e9c547734d0..0000000000000000000000000000000000000000
--- a/spaces/801artistry/RVC801/infer/lib/infer_pack/onnx_inference.py
+++ /dev/null
@@ -1,149 +0,0 @@
-import librosa
-import numpy as np
-import onnxruntime
-import soundfile
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class ContentVec:
-    def __init__(self, vec_path="pretrained/vec-768-layer-12.onnx", device=None):
-        logger.info("Load model(s) from {}".format(vec_path))
-        if device == "cpu" or device is None:
-            providers = ["CPUExecutionProvider"]
-        elif device == "cuda":
-            providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
-        elif device == "dml":
-            providers = ["DmlExecutionProvider"]
-        else:
-            raise RuntimeError("Unsportted Device")
-        self.model = onnxruntime.InferenceSession(vec_path, providers=providers)
-
-    def __call__(self, wav):
-        return self.forward(wav)
-
-    def forward(self, wav):
-        feats = wav
-        if feats.ndim == 2:  # double channels
-            feats = feats.mean(-1)
-        assert feats.ndim == 1, feats.ndim
-        feats = np.expand_dims(np.expand_dims(feats, 0), 0)
-        onnx_input = {self.model.get_inputs()[0].name: feats}
-        logits = self.model.run(None, onnx_input)[0]
-        return logits.transpose(0, 2, 1)
-
-
-def get_f0_predictor(f0_predictor, hop_length, sampling_rate, **kargs):
-    if f0_predictor == "pm":
-        from lib.infer_pack.modules.F0Predictor.PMF0Predictor import PMF0Predictor
-
-        f0_predictor_object = PMF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    elif f0_predictor == "harvest":
-        from lib.infer_pack.modules.F0Predictor.HarvestF0Predictor import (
-            HarvestF0Predictor,
-        )
-
-        f0_predictor_object = HarvestF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    elif f0_predictor == "dio":
-        from lib.infer_pack.modules.F0Predictor.DioF0Predictor import DioF0Predictor
-
-        f0_predictor_object = DioF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    else:
-        raise Exception("Unknown f0 predictor")
-    return f0_predictor_object
-
-
-class OnnxRVC:
-    def __init__(
-        self,
-        model_path,
-        sr=40000,
-        hop_size=512,
-        vec_path="vec-768-layer-12",
-        device="cpu",
-    ):
-        vec_path = f"pretrained/{vec_path}.onnx"
-        self.vec_model = ContentVec(vec_path, device)
-        if device == "cpu" or device is None:
-            providers = ["CPUExecutionProvider"]
-        elif device == "cuda":
-            providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
-        elif device == "dml":
-            providers = ["DmlExecutionProvider"]
-        else:
-            raise RuntimeError("Unsportted Device")
-        self.model = onnxruntime.InferenceSession(model_path, providers=providers)
-        self.sampling_rate = sr
-        self.hop_size = hop_size
-
-    def forward(self, hubert, hubert_length, pitch, pitchf, ds, rnd):
-        onnx_input = {
-            self.model.get_inputs()[0].name: hubert,
-            self.model.get_inputs()[1].name: hubert_length,
-            self.model.get_inputs()[2].name: pitch,
-            self.model.get_inputs()[3].name: pitchf,
-            self.model.get_inputs()[4].name: ds,
-            self.model.get_inputs()[5].name: rnd,
-        }
-        return (self.model.run(None, onnx_input)[0] * 32767).astype(np.int16)
-
-    def inference(
-        self,
-        raw_path,
-        sid,
-        f0_method="dio",
-        f0_up_key=0,
-        pad_time=0.5,
-        cr_threshold=0.02,
-    ):
-        f0_min = 50
-        f0_max = 1100
-        f0_mel_min = 1127 * np.log(1 + f0_min / 700)
-        f0_mel_max = 1127 * np.log(1 + f0_max / 700)
-        f0_predictor = get_f0_predictor(
-            f0_method,
-            hop_length=self.hop_size,
-            sampling_rate=self.sampling_rate,
-            threshold=cr_threshold,
-        )
-        wav, sr = librosa.load(raw_path, sr=self.sampling_rate)
-        org_length = len(wav)
-        if org_length / sr > 50.0:
-            raise RuntimeError("Reached Max Length")
-
-        wav16k = librosa.resample(wav, orig_sr=self.sampling_rate, target_sr=16000)
-        wav16k = wav16k
-
-        hubert = self.vec_model(wav16k)
-        hubert = np.repeat(hubert, 2, axis=2).transpose(0, 2, 1).astype(np.float32)
-        hubert_length = hubert.shape[1]
-
-        pitchf = f0_predictor.compute_f0(wav, hubert_length)
-        pitchf = pitchf * 2 ** (f0_up_key / 12)
-        pitch = pitchf.copy()
-        f0_mel = 1127 * np.log(1 + pitch / 700)
-        f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (
-            f0_mel_max - f0_mel_min
-        ) + 1
-        f0_mel[f0_mel <= 1] = 1
-        f0_mel[f0_mel > 255] = 255
-        pitch = np.rint(f0_mel).astype(np.int64)
-
-        pitchf = pitchf.reshape(1, len(pitchf)).astype(np.float32)
-        pitch = pitch.reshape(1, len(pitch))
-        ds = np.array([sid]).astype(np.int64)
-
-        rnd = np.random.randn(1, 192, hubert_length).astype(np.float32)
-        hubert_length = np.array([hubert_length]).astype(np.int64)
-
-        out_wav = self.forward(hubert, hubert_length, pitch, pitchf, ds, rnd).squeeze()
-        out_wav = np.pad(out_wav, (0, 2 * self.hop_size), "constant")
-        return out_wav[0:org_length]
diff --git a/spaces/AIFILMS/StyleGANEX/models/stylegan2/op_ori/upfirdn2d.cpp b/spaces/AIFILMS/StyleGANEX/models/stylegan2/op_ori/upfirdn2d.cpp
deleted file mode 100644
index d2e633dc896433c205e18bc3e455539192ff968e..0000000000000000000000000000000000000000
--- a/spaces/AIFILMS/StyleGANEX/models/stylegan2/op_ori/upfirdn2d.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <torch/extension.h>
-
-
-torch::Tensor upfirdn2d_op(const torch::Tensor& input, const torch::Tensor& kernel,
-                            int up_x, int up_y, int down_x, int down_y,
-                            int pad_x0, int pad_x1, int pad_y0, int pad_y1);
-
-#define CHECK_CUDA(x) TORCH_CHECK(x.type().is_cuda(), #x " must be a CUDA tensor")
-#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be contiguous")
-#define CHECK_INPUT(x) CHECK_CUDA(x); CHECK_CONTIGUOUS(x)
-
-torch::Tensor upfirdn2d(const torch::Tensor& input, const torch::Tensor& kernel,
-                        int up_x, int up_y, int down_x, int down_y,
-                        int pad_x0, int pad_x1, int pad_y0, int pad_y1) {
-    CHECK_CUDA(input);
-    CHECK_CUDA(kernel);
-
-    return upfirdn2d_op(input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1, pad_y0, pad_y1);
-}
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
-    m.def("upfirdn2d", &upfirdn2d, "upfirdn2d (CUDA)");
-}
\ No newline at end of file
diff --git a/spaces/AIGC-Audio/Make_An_Audio/ldm/modules/diffusionmodules/__init__.py b/spaces/AIGC-Audio/Make_An_Audio/ldm/modules/diffusionmodules/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/AIGC-Audio/Make_An_Audio_inpaint/ldm/modules/losses_audio/vggishish/predict.py b/spaces/AIGC-Audio/Make_An_Audio_inpaint/ldm/modules/losses_audio/vggishish/predict.py
deleted file mode 100644
index e9d13f30153cd43a4a8bcfe2da4b9a53846bf1eb..0000000000000000000000000000000000000000
--- a/spaces/AIGC-Audio/Make_An_Audio_inpaint/ldm/modules/losses_audio/vggishish/predict.py
+++ /dev/null
@@ -1,90 +0,0 @@
-import os
-from torch.utils.data import DataLoader
-import torchvision
-from tqdm import tqdm
-from dataset import VGGSound
-import torch
-import torch.nn as nn
-from metrics import metrics
-from omegaconf import OmegaConf
-from model import VGGishish
-from transforms import Crop, StandardNormalizeAudio, ToTensor
-
-
-if __name__ == '__main__':
-    cfg_cli = OmegaConf.from_cli()
-    print(cfg_cli.config)
-    cfg_yml = OmegaConf.load(cfg_cli.config)
-    # the latter arguments are prioritized
-    cfg = OmegaConf.merge(cfg_yml, cfg_cli)
-    OmegaConf.set_readonly(cfg, True)
-    print(OmegaConf.to_yaml(cfg))
-
-    # logger = LoggerWithTBoard(cfg)
-    transforms = [
-        StandardNormalizeAudio(cfg.mels_path),
-        ToTensor(),
-    ]
-    if cfg.cropped_size not in [None, 'None', 'none']:
-        transforms.append(Crop(cfg.cropped_size))
-    transforms = torchvision.transforms.transforms.Compose(transforms)
-
-    datasets = {
-        'test': VGGSound('test', cfg.mels_path, transforms),
-    }
-
-    loaders = {
-        'test': DataLoader(datasets['test'], batch_size=cfg.batch_size,
-                           num_workers=cfg.num_workers, pin_memory=True)
-    }
-
-    device = torch.device(cfg.device if torch.cuda.is_available() else 'cpu')
-    model = VGGishish(cfg.conv_layers, cfg.use_bn, num_classes=len(datasets['test'].target2label))
-    model = model.to(device)
-
-    optimizer = torch.optim.Adam(model.parameters(), lr=cfg.learning_rate)
-    criterion = nn.CrossEntropyLoss()
-
-    # loading the best model
-    folder_name = os.path.split(cfg.config)[0].split('/')[-1]
-    print(folder_name)
-    ckpt = torch.load(f'./logs/{folder_name}/vggishish-{folder_name}.pt', map_location='cpu')
-    model.load_state_dict(ckpt['model'])
-    print((f'The model was trained for {ckpt["epoch"]} epochs. Loss: {ckpt["loss"]:.4f}'))
-
-    # Testing the model
-    model.eval()
-    running_loss = 0
-    preds_from_each_batch = []
-    targets_from_each_batch = []
-
-    for i, batch in enumerate(tqdm(loaders['test'])):
-        inputs = batch['input'].to(device)
-        targets = batch['target'].to(device)
-
-        # zero the parameter gradients
-        optimizer.zero_grad()
-
-        # forward + backward + optimize
-        with torch.set_grad_enabled(False):
-            outputs = model(inputs)
-            loss = criterion(outputs, targets)
-
-        # loss
-        running_loss += loss.item()
-
-        # for metrics calculation later on
-        preds_from_each_batch += [outputs.detach().cpu()]
-        targets_from_each_batch += [targets.cpu()]
-
-    # logging metrics
-    preds_from_each_batch = torch.cat(preds_from_each_batch)
-    targets_from_each_batch = torch.cat(targets_from_each_batch)
-    test_metrics_dict = metrics(targets_from_each_batch, preds_from_each_batch)
-    test_metrics_dict['avg_loss'] = running_loss / len(loaders['test'])
-    test_metrics_dict['param_num'] = sum(p.numel() for p in model.parameters() if p.requires_grad)
-
-    # TODO: I have no idea why tboard doesn't keep metrics (hparams) in a tensorboard when
-    # I run this experiment from cli: `python main.py config=./configs/vggish.yaml`
-    # while when I run it in vscode debugger the metrics are present in the tboard (weird)
-    print(test_metrics_dict)
diff --git a/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnet/resnet50_8xb16_cifar100.py b/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnet/resnet50_8xb16_cifar100.py
deleted file mode 100644
index ebde6c76ecca6d23b58edfb85ebc3b72ce15a2b2..0000000000000000000000000000000000000000
--- a/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnet/resnet50_8xb16_cifar100.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = [
-    '../_base_/models/resnet50_cifar.py',
-    '../_base_/datasets/cifar100_bs16.py',
-    '../_base_/schedules/cifar10_bs128.py',
-    '../_base_/default_runtime.py',
-]
-
-# model settings
-model = dict(head=dict(num_classes=100))
-
-# schedule settings
-optim_wrapper = dict(optimizer=dict(weight_decay=0.0005))
-
-param_scheduler = dict(
-    type='MultiStepLR',
-    by_epoch=True,
-    milestones=[60, 120, 160],
-    gamma=0.2,
-)
diff --git a/spaces/Adapter/CoAdapter/ldm/models/autoencoder.py b/spaces/Adapter/CoAdapter/ldm/models/autoencoder.py
deleted file mode 100644
index e3ff5fe3ed0f70de8b31f1af27e107b93fbb94ca..0000000000000000000000000000000000000000
--- a/spaces/Adapter/CoAdapter/ldm/models/autoencoder.py
+++ /dev/null
@@ -1,211 +0,0 @@
-import torch
-import pytorch_lightning as pl
-import torch.nn.functional as F
-import torch.nn as nn
-from contextlib import contextmanager
-
-from ldm.modules.diffusionmodules.model import Encoder, Decoder
-from ldm.modules.distributions.distributions import DiagonalGaussianDistribution
-
-from ldm.util import instantiate_from_config
-from ldm.modules.ema import LitEma
-
-
-class AutoencoderKL(pl.LightningModule):
-    def __init__(self,
-                 ddconfig,
-                 lossconfig,
-                 embed_dim,
-                 ckpt_path=None,
-                 ignore_keys=[],
-                 image_key="image",
-                 colorize_nlabels=None,
-                 monitor=None,
-                 ema_decay=None,
-                 learn_logvar=False
-                 ):
-        super().__init__()
-        self.learn_logvar = learn_logvar
-        self.image_key = image_key
-        self.encoder = Encoder(**ddconfig)
-        self.decoder = Decoder(**ddconfig)
-        self.loss = instantiate_from_config(lossconfig)
-        assert ddconfig["double_z"]
-        self.quant_conv = torch.nn.Conv2d(2*ddconfig["z_channels"], 2*embed_dim, 1)
-        self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1)
-        self.embed_dim = embed_dim
-        if colorize_nlabels is not None:
-            assert type(colorize_nlabels)==int
-            self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1))
-        if monitor is not None:
-            self.monitor = monitor
-
-        self.use_ema = ema_decay is not None
-        if self.use_ema:
-            self.ema_decay = ema_decay
-            assert 0. < ema_decay < 1.
-            self.model_ema = LitEma(self, decay=ema_decay)
-            print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")
-
-        if ckpt_path is not None:
-            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
-
-    def init_from_ckpt(self, path, ignore_keys=list()):
-        sd = torch.load(path, map_location="cpu")["state_dict"]
-        keys = list(sd.keys())
-        for k in keys:
-            for ik in ignore_keys:
-                if k.startswith(ik):
-                    print("Deleting key {} from state_dict.".format(k))
-                    del sd[k]
-        self.load_state_dict(sd, strict=False)
-        print(f"Restored from {path}")
-
-    @contextmanager
-    def ema_scope(self, context=None):
-        if self.use_ema:
-            self.model_ema.store(self.parameters())
-            self.model_ema.copy_to(self)
-            if context is not None:
-                print(f"{context}: Switched to EMA weights")
-        try:
-            yield None
-        finally:
-            if self.use_ema:
-                self.model_ema.restore(self.parameters())
-                if context is not None:
-                    print(f"{context}: Restored training weights")
-
-    def on_train_batch_end(self, *args, **kwargs):
-        if self.use_ema:
-            self.model_ema(self)
-
-    def encode(self, x):
-        h = self.encoder(x)
-        moments = self.quant_conv(h)
-        posterior = DiagonalGaussianDistribution(moments)
-        return posterior
-
-    def decode(self, z):
-        z = self.post_quant_conv(z)
-        dec = self.decoder(z)
-        return dec
-
-    def forward(self, input, sample_posterior=True):
-        posterior = self.encode(input)
-        if sample_posterior:
-            z = posterior.sample()
-        else:
-            z = posterior.mode()
-        dec = self.decode(z)
-        return dec, posterior
-
-    def get_input(self, batch, k):
-        x = batch[k]
-        if len(x.shape) == 3:
-            x = x[..., None]
-        x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format).float()
-        return x
-
-    def training_step(self, batch, batch_idx, optimizer_idx):
-        inputs = self.get_input(batch, self.image_key)
-        reconstructions, posterior = self(inputs)
-
-        if optimizer_idx == 0:
-            # train encoder+decoder+logvar
-            aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
-                                            last_layer=self.get_last_layer(), split="train")
-            self.log("aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
-            self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=False)
-            return aeloss
-
-        if optimizer_idx == 1:
-            # train the discriminator
-            discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
-                                                last_layer=self.get_last_layer(), split="train")
-
-            self.log("discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
-            self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=False)
-            return discloss
-
-    def validation_step(self, batch, batch_idx):
-        log_dict = self._validation_step(batch, batch_idx)
-        with self.ema_scope():
-            log_dict_ema = self._validation_step(batch, batch_idx, postfix="_ema")
-        return log_dict
-
-    def _validation_step(self, batch, batch_idx, postfix=""):
-        inputs = self.get_input(batch, self.image_key)
-        reconstructions, posterior = self(inputs)
-        aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, 0, self.global_step,
-                                        last_layer=self.get_last_layer(), split="val"+postfix)
-
-        discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, 1, self.global_step,
-                                            last_layer=self.get_last_layer(), split="val"+postfix)
-
-        self.log(f"val{postfix}/rec_loss", log_dict_ae[f"val{postfix}/rec_loss"])
-        self.log_dict(log_dict_ae)
-        self.log_dict(log_dict_disc)
-        return self.log_dict
-
-    def configure_optimizers(self):
-        lr = self.learning_rate
-        ae_params_list = list(self.encoder.parameters()) + list(self.decoder.parameters()) + list(
-            self.quant_conv.parameters()) + list(self.post_quant_conv.parameters())
-        if self.learn_logvar:
-            print(f"{self.__class__.__name__}: Learning logvar")
-            ae_params_list.append(self.loss.logvar)
-        opt_ae = torch.optim.Adam(ae_params_list,
-                                  lr=lr, betas=(0.5, 0.9))
-        opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(),
-                                    lr=lr, betas=(0.5, 0.9))
-        return [opt_ae, opt_disc], []
-
-    def get_last_layer(self):
-        return self.decoder.conv_out.weight
-
-    @torch.no_grad()
-    def log_images(self, batch, only_inputs=False, log_ema=False, **kwargs):
-        log = dict()
-        x = self.get_input(batch, self.image_key)
-        x = x.to(self.device)
-        if not only_inputs:
-            xrec, posterior = self(x)
-            if x.shape[1] > 3:
-                # colorize with random projection
-                assert xrec.shape[1] > 3
-                x = self.to_rgb(x)
-                xrec = self.to_rgb(xrec)
-            log["samples"] = self.decode(torch.randn_like(posterior.sample()))
-            log["reconstructions"] = xrec
-        log["inputs"] = x
-        return log
-
-    def to_rgb(self, x):
-        assert self.image_key == "segmentation"
-        if not hasattr(self, "colorize"):
-            self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x))
-        x = F.conv2d(x, weight=self.colorize)
-        x = 2.*(x-x.min())/(x.max()-x.min()) - 1.
-        return x
-
-
-class IdentityFirstStage(nn.Module):
-    def __init__(self, *args, vq_interface=False, **kwargs):
-        self.vq_interface = vq_interface
-        super().__init__()
-
-    def encode(self, x, *args, **kwargs):
-        return x
-
-    def decode(self, x, *args, **kwargs):
-        return x
-
-    def quantize(self, x, *args, **kwargs):
-        if self.vq_interface:
-            return x, None, [None, None, None]
-        return x
-
-    def forward(self, x, *args, **kwargs):
-        return x
-
diff --git a/spaces/Adapter/CoAdapter/ldm/models/diffusion/dpm_solver/sampler.py b/spaces/Adapter/CoAdapter/ldm/models/diffusion/dpm_solver/sampler.py
deleted file mode 100644
index fc2c96baf2bf5f8de3684c198bcd1b0df5b51149..0000000000000000000000000000000000000000
--- a/spaces/Adapter/CoAdapter/ldm/models/diffusion/dpm_solver/sampler.py
+++ /dev/null
@@ -1,87 +0,0 @@
-"""SAMPLING ONLY."""
-import torch
-
-from .dpm_solver import NoiseScheduleVP, model_wrapper, DPM_Solver
-
-
-MODEL_TYPES = {
-    "eps": "noise",
-    "v": "v"
-}
-
-
-class DPMSolverSampler(object):
-    def __init__(self, model, **kwargs):
-        super().__init__()
-        self.model = model
-        to_torch = lambda x: x.clone().detach().to(torch.float32).to(model.device)
-        self.register_buffer('alphas_cumprod', to_torch(model.alphas_cumprod))
-
-    def register_buffer(self, name, attr):
-        if type(attr) == torch.Tensor:
-            if attr.device != torch.device("cuda"):
-                attr = attr.to(torch.device("cuda"))
-        setattr(self, name, attr)
-
-    @torch.no_grad()
-    def sample(self,
-               S,
-               batch_size,
-               shape,
-               conditioning=None,
-               callback=None,
-               normals_sequence=None,
-               img_callback=None,
-               quantize_x0=False,
-               eta=0.,
-               mask=None,
-               x0=None,
-               temperature=1.,
-               noise_dropout=0.,
-               score_corrector=None,
-               corrector_kwargs=None,
-               verbose=True,
-               x_T=None,
-               log_every_t=100,
-               unconditional_guidance_scale=1.,
-               unconditional_conditioning=None,
-               # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...
-               **kwargs
-               ):
-        if conditioning is not None:
-            if isinstance(conditioning, dict):
-                cbs = conditioning[list(conditioning.keys())[0]].shape[0]
-                if cbs != batch_size:
-                    print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
-            else:
-                if conditioning.shape[0] != batch_size:
-                    print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}")
-
-        # sampling
-        C, H, W = shape
-        size = (batch_size, C, H, W)
-
-        print(f'Data shape for DPM-Solver sampling is {size}, sampling steps {S}')
-
-        device = self.model.betas.device
-        if x_T is None:
-            img = torch.randn(size, device=device)
-        else:
-            img = x_T
-
-        ns = NoiseScheduleVP('discrete', alphas_cumprod=self.alphas_cumprod)
-
-        model_fn = model_wrapper(
-            lambda x, t, c: self.model.apply_model(x, t, c),
-            ns,
-            model_type=MODEL_TYPES[self.model.parameterization],
-            guidance_type="classifier-free",
-            condition=conditioning,
-            unconditional_condition=unconditional_conditioning,
-            guidance_scale=unconditional_guidance_scale,
-        )
-
-        dpm_solver = DPM_Solver(model_fn, ns, predict_x0=True, thresholding=False)
-        x = dpm_solver.sample(img, steps=S, skip_type="time_uniform", method="multistep", order=2, lower_order_final=True)
-
-        return x.to(device), None
diff --git a/spaces/Adapter/CoAdapter/ldm/modules/diffusionmodules/openaimodel.py b/spaces/Adapter/CoAdapter/ldm/modules/diffusionmodules/openaimodel.py
deleted file mode 100644
index 09972d58e1a65b88909dfe35c12c9126851da5cf..0000000000000000000000000000000000000000
--- a/spaces/Adapter/CoAdapter/ldm/modules/diffusionmodules/openaimodel.py
+++ /dev/null
@@ -1,798 +0,0 @@
-from abc import abstractmethod
-import math
-import torch
-
-import numpy as np
-import torch as th
-import torch.nn as nn
-import torch.nn.functional as F
-
-from ldm.modules.diffusionmodules.util import (
-    checkpoint,
-    conv_nd,
-    linear,
-    avg_pool_nd,
-    zero_module,
-    normalization,
-    timestep_embedding,
-)
-from ldm.modules.attention import SpatialTransformer
-from ldm.util import exists
-
-
-# dummy replace
-def convert_module_to_f16(x):
-    pass
-
-def convert_module_to_f32(x):
-    pass
-
-
-## go
-class AttentionPool2d(nn.Module):
-    """
-    Adapted from CLIP: https://github.com/openai/CLIP/blob/main/clip/model.py
-    """
-
-    def __init__(
-        self,
-        spacial_dim: int,
-        embed_dim: int,
-        num_heads_channels: int,
-        output_dim: int = None,
-    ):
-        super().__init__()
-        self.positional_embedding = nn.Parameter(th.randn(embed_dim, spacial_dim ** 2 + 1) / embed_dim ** 0.5)
-        self.qkv_proj = conv_nd(1, embed_dim, 3 * embed_dim, 1)
-        self.c_proj = conv_nd(1, embed_dim, output_dim or embed_dim, 1)
-        self.num_heads = embed_dim // num_heads_channels
-        self.attention = QKVAttention(self.num_heads)
-
-    def forward(self, x):
-        b, c, *_spatial = x.shape
-        x = x.reshape(b, c, -1)  # NC(HW)
-        x = th.cat([x.mean(dim=-1, keepdim=True), x], dim=-1)  # NC(HW+1)
-        x = x + self.positional_embedding[None, :, :].to(x.dtype)  # NC(HW+1)
-        x = self.qkv_proj(x)
-        x = self.attention(x)
-        x = self.c_proj(x)
-        return x[:, :, 0]
-
-
-class TimestepBlock(nn.Module):
-    """
-    Any module where forward() takes timestep embeddings as a second argument.
-    """
-
-    @abstractmethod
-    def forward(self, x, emb):
-        """
-        Apply the module to `x` given `emb` timestep embeddings.
-        """
-
-
-class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
-    """
-    A sequential module that passes timestep embeddings to the children that
-    support it as an extra input.
-    """
-
-    def forward(self, x, emb, context=None):
-        for layer in self:
-            if isinstance(layer, TimestepBlock):
-                x = layer(x, emb)
-            elif isinstance(layer, SpatialTransformer):
-                x = layer(x, context)
-            else:
-                x = layer(x)
-        return x
-
-
-class Upsample(nn.Module):
-    """
-    An upsampling layer with an optional convolution.
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 upsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        if use_conv:
-            self.conv = conv_nd(dims, self.channels, self.out_channels, 3, padding=padding)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        if self.dims == 3:
-            x = F.interpolate(
-                x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest"
-            )
-        else:
-            x = F.interpolate(x, scale_factor=2, mode="nearest")
-        if self.use_conv:
-            x = self.conv(x)
-        return x
-
-class TransposedUpsample(nn.Module):
-    'Learned 2x upsampling without padding'
-    def __init__(self, channels, out_channels=None, ks=5):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-
-        self.up = nn.ConvTranspose2d(self.channels,self.out_channels,kernel_size=ks,stride=2)
-
-    def forward(self,x):
-        return self.up(x)
-
-
-class Downsample(nn.Module):
-    """
-    A downsampling layer with an optional convolution.
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 downsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None,padding=1):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        stride = 2 if dims != 3 else (1, 2, 2)
-        if use_conv:
-            self.op = conv_nd(
-                dims, self.channels, self.out_channels, 3, stride=stride, padding=padding
-            )
-        else:
-            assert self.channels == self.out_channels
-            self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        return self.op(x)
-
-
-class ResBlock(TimestepBlock):
-    """
-    A residual block that can optionally change the number of channels.
-    :param channels: the number of input channels.
-    :param emb_channels: the number of timestep embedding channels.
-    :param dropout: the rate of dropout.
-    :param out_channels: if specified, the number of out channels.
-    :param use_conv: if True and out_channels is specified, use a spatial
-        convolution instead of a smaller 1x1 convolution to change the
-        channels in the skip connection.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param use_checkpoint: if True, use gradient checkpointing on this module.
-    :param up: if True, use this block for upsampling.
-    :param down: if True, use this block for downsampling.
-    """
-
-    def __init__(
-        self,
-        channels,
-        emb_channels,
-        dropout,
-        out_channels=None,
-        use_conv=False,
-        use_scale_shift_norm=False,
-        dims=2,
-        use_checkpoint=False,
-        up=False,
-        down=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.emb_channels = emb_channels
-        self.dropout = dropout
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.use_checkpoint = use_checkpoint
-        self.use_scale_shift_norm = use_scale_shift_norm
-
-        self.in_layers = nn.Sequential(
-            normalization(channels),
-            nn.SiLU(),
-            conv_nd(dims, channels, self.out_channels, 3, padding=1),
-        )
-
-        self.updown = up or down
-
-        if up:
-            self.h_upd = Upsample(channels, False, dims)
-            self.x_upd = Upsample(channels, False, dims)
-        elif down:
-            self.h_upd = Downsample(channels, False, dims)
-            self.x_upd = Downsample(channels, False, dims)
-        else:
-            self.h_upd = self.x_upd = nn.Identity()
-
-        self.emb_layers = nn.Sequential(
-            nn.SiLU(),
-            linear(
-                emb_channels,
-                2 * self.out_channels if use_scale_shift_norm else self.out_channels,
-            ),
-        )
-        self.out_layers = nn.Sequential(
-            normalization(self.out_channels),
-            nn.SiLU(),
-            nn.Dropout(p=dropout),
-            zero_module(
-                conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1)
-            ),
-        )
-
-        if self.out_channels == channels:
-            self.skip_connection = nn.Identity()
-        elif use_conv:
-            self.skip_connection = conv_nd(
-                dims, channels, self.out_channels, 3, padding=1
-            )
-        else:
-            self.skip_connection = conv_nd(dims, channels, self.out_channels, 1)
-
-    def forward(self, x, emb):
-        """
-        Apply the block to a Tensor, conditioned on a timestep embedding.
-        :param x: an [N x C x ...] Tensor of features.
-        :param emb: an [N x emb_channels] Tensor of timestep embeddings.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        return checkpoint(
-            self._forward, (x, emb), self.parameters(), self.use_checkpoint
-        )
-
-
-    def _forward(self, x, emb):
-        if self.updown:
-            in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1]
-            h = in_rest(x)
-            h = self.h_upd(h)
-            x = self.x_upd(x)
-            h = in_conv(h)
-        else:
-            h = self.in_layers(x)
-        emb_out = self.emb_layers(emb).type(h.dtype)
-        while len(emb_out.shape) < len(h.shape):
-            emb_out = emb_out[..., None]
-        if self.use_scale_shift_norm:
-            out_norm, out_rest = self.out_layers[0], self.out_layers[1:]
-            scale, shift = th.chunk(emb_out, 2, dim=1)
-            h = out_norm(h) * (1 + scale) + shift
-            h = out_rest(h)
-        else:
-            h = h + emb_out
-            h = self.out_layers(h)
-        return self.skip_connection(x) + h
-
-
-class AttentionBlock(nn.Module):
-    """
-    An attention block that allows spatial positions to attend to each other.
-    Originally ported from here, but adapted to the N-d case.
-    https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66.
-    """
-
-    def __init__(
-        self,
-        channels,
-        num_heads=1,
-        num_head_channels=-1,
-        use_checkpoint=False,
-        use_new_attention_order=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        if num_head_channels == -1:
-            self.num_heads = num_heads
-        else:
-            assert (
-                channels % num_head_channels == 0
-            ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}"
-            self.num_heads = channels // num_head_channels
-        self.use_checkpoint = use_checkpoint
-        self.norm = normalization(channels)
-        self.qkv = conv_nd(1, channels, channels * 3, 1)
-        if use_new_attention_order:
-            # split qkv before split heads
-            self.attention = QKVAttention(self.num_heads)
-        else:
-            # split heads before split qkv
-            self.attention = QKVAttentionLegacy(self.num_heads)
-
-        self.proj_out = zero_module(conv_nd(1, channels, channels, 1))
-
-    def forward(self, x):
-        return checkpoint(self._forward, (x,), self.parameters(), True)   # TODO: check checkpoint usage, is True # TODO: fix the .half call!!!
-        #return pt_checkpoint(self._forward, x)  # pytorch
-
-    def _forward(self, x):
-        b, c, *spatial = x.shape
-        x = x.reshape(b, c, -1)
-        qkv = self.qkv(self.norm(x))
-        h = self.attention(qkv)
-        h = self.proj_out(h)
-        return (x + h).reshape(b, c, *spatial)
-
-
-def count_flops_attn(model, _x, y):
-    """
-    A counter for the `thop` package to count the operations in an
-    attention operation.
-    Meant to be used like:
-        macs, params = thop.profile(
-            model,
-            inputs=(inputs, timestamps),
-            custom_ops={QKVAttention: QKVAttention.count_flops},
-        )
-    """
-    b, c, *spatial = y[0].shape
-    num_spatial = int(np.prod(spatial))
-    # We perform two matmuls with the same number of ops.
-    # The first computes the weight matrix, the second computes
-    # the combination of the value vectors.
-    matmul_ops = 2 * b * (num_spatial ** 2) * c
-    model.total_ops += th.DoubleTensor([matmul_ops])
-
-
-class QKVAttentionLegacy(nn.Module):
-    """
-    A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-        :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts", q * scale, k * scale
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v)
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class QKVAttention(nn.Module):
-    """
-    A module which performs QKV attention and splits in a different order.
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-        :param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.chunk(3, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts",
-            (q * scale).view(bs * self.n_heads, ch, length),
-            (k * scale).view(bs * self.n_heads, ch, length),
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length))
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class UNetModel(nn.Module):
-    """
-    The full UNet model with attention and timestep embedding.
-    :param in_channels: channels in the input Tensor.
-    :param model_channels: base channel count for the model.
-    :param out_channels: channels in the output Tensor.
-    :param num_res_blocks: number of residual blocks per downsample.
-    :param attention_resolutions: a collection of downsample rates at which
-        attention will take place. May be a set, list, or tuple.
-        For example, if this contains 4, then at 4x downsampling, attention
-        will be used.
-    :param dropout: the dropout probability.
-    :param channel_mult: channel multiplier for each level of the UNet.
-    :param conv_resample: if True, use learned convolutions for upsampling and
-        downsampling.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param num_classes: if specified (as an int), then this model will be
-        class-conditional with `num_classes` classes.
-    :param use_checkpoint: use gradient checkpointing to reduce memory usage.
-    :param num_heads: the number of attention heads in each attention layer.
-    :param num_heads_channels: if specified, ignore num_heads and instead use
-                               a fixed channel width per attention head.
-    :param num_heads_upsample: works with num_heads to set a different number
-                               of heads for upsampling. Deprecated.
-    :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
-    :param resblock_updown: use residual blocks for up/downsampling.
-    :param use_new_attention_order: use a different attention pattern for potentially
-                                    increased efficiency.
-    """
-
-    def __init__(
-        self,
-        image_size,
-        in_channels,
-        model_channels,
-        out_channels,
-        num_res_blocks,
-        attention_resolutions,
-        dropout=0,
-        channel_mult=(1, 2, 4, 8),
-        conv_resample=True,
-        dims=2,
-        num_classes=None,
-        use_checkpoint=False,
-        use_fp16=False,
-        num_heads=-1,
-        num_head_channels=-1,
-        num_heads_upsample=-1,
-        use_scale_shift_norm=False,
-        resblock_updown=False,
-        use_new_attention_order=False,
-        use_spatial_transformer=False,    # custom transformer support
-        transformer_depth=1,              # custom transformer support
-        context_dim=None,                 # custom transformer support
-        n_embed=None,                     # custom support for prediction of discrete ids into codebook of first stage vq model
-        legacy=True,
-        disable_self_attentions=None,
-        num_attention_blocks=None,
-        disable_middle_self_attn=False,
-        use_linear_in_transformer=False,
-    ):
-        super().__init__()
-        if use_spatial_transformer:
-            assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...'
-
-        if context_dim is not None:
-            assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...'
-            from omegaconf.listconfig import ListConfig
-            if type(context_dim) == ListConfig:
-                context_dim = list(context_dim)
-
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-
-        if num_heads == -1:
-            assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'
-
-        if num_head_channels == -1:
-            assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'
-
-        self.image_size = image_size
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        if isinstance(num_res_blocks, int):
-            self.num_res_blocks = len(channel_mult) * [num_res_blocks]
-        else:
-            if len(num_res_blocks) != len(channel_mult):
-                raise ValueError("provide num_res_blocks either as an int (globally constant) or "
-                                 "as a list/tuple (per-level) with the same length as channel_mult")
-            self.num_res_blocks = num_res_blocks
-        if disable_self_attentions is not None:
-            # should be a list of booleans, indicating whether to disable self-attention in TransformerBlocks or not
-            assert len(disable_self_attentions) == len(channel_mult)
-        if num_attention_blocks is not None:
-            assert len(num_attention_blocks) == len(self.num_res_blocks)
-            assert all(map(lambda i: self.num_res_blocks[i] >= num_attention_blocks[i], range(len(num_attention_blocks))))
-            print(f"Constructor of UNetModel received num_attention_blocks={num_attention_blocks}. "
-                  f"This option has LESS priority than attention_resolutions {attention_resolutions}, "
-                  f"i.e., in cases where num_attention_blocks[i] > 0 but 2**i not in attention_resolutions, "
-                  f"attention will still not be set.")
-
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        self.conv_resample = conv_resample
-        self.num_classes = num_classes
-        self.use_checkpoint = use_checkpoint
-        self.dtype = th.float16 if use_fp16 else th.float32
-        self.num_heads = num_heads
-        self.num_head_channels = num_head_channels
-        self.num_heads_upsample = num_heads_upsample
-        self.predict_codebook_ids = n_embed is not None
-
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim),
-        )
-
-        if self.num_classes is not None:
-            if isinstance(self.num_classes, int):
-                self.label_emb = nn.Embedding(num_classes, time_embed_dim)
-            elif self.num_classes == "continuous":
-                print("setting up linear c_adm embedding layer")
-                self.label_emb = nn.Linear(1, time_embed_dim)
-            else:
-                raise ValueError()
-
-        self.input_blocks = nn.ModuleList(
-            [
-                TimestepEmbedSequential(
-                    conv_nd(dims, in_channels, model_channels, 3, padding=1)
-                )
-            ]
-        )
-        self._feature_size = model_channels
-        input_block_chans = [model_channels]
-        ch = model_channels
-        ds = 1
-        for level, mult in enumerate(channel_mult):
-            for nr in range(self.num_res_blocks[level]):
-                layers = [
-                    ResBlock(
-                        ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=mult * model_channels,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = mult * model_channels
-                if ds in attention_resolutions:
-                    if num_head_channels == -1:
-                        dim_head = ch // num_heads
-                    else:
-                        num_heads = ch // num_head_channels
-                        dim_head = num_head_channels
-                    if legacy:
-                        #num_heads = 1
-                        dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-                    if exists(disable_self_attentions):
-                        disabled_sa = disable_self_attentions[level]
-                    else:
-                        disabled_sa = False
-
-                    if not exists(num_attention_blocks) or nr < num_attention_blocks[level]:
-                        layers.append(
-                            AttentionBlock(
-                                ch,
-                                use_checkpoint=use_checkpoint,
-                                num_heads=num_heads,
-                                num_head_channels=dim_head,
-                                use_new_attention_order=use_new_attention_order,
-                            ) if not use_spatial_transformer else SpatialTransformer(
-                                ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim,
-                                disable_self_attn=disabled_sa, use_linear=use_linear_in_transformer,
-                                use_checkpoint=use_checkpoint
-                            )
-                        )
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-            if level != len(channel_mult) - 1:
-                out_ch = ch
-                self.input_blocks.append(
-                    TimestepEmbedSequential(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            down=True,
-                        )
-                        if resblock_updown
-                        else Downsample(
-                            ch, conv_resample, dims=dims, out_channels=out_ch
-                        )
-                    )
-                )
-                ch = out_ch
-                input_block_chans.append(ch)
-                ds *= 2
-                self._feature_size += ch
-
-        if num_head_channels == -1:
-            dim_head = ch // num_heads
-        else:
-            num_heads = ch // num_head_channels
-            dim_head = num_head_channels
-        if legacy:
-            #num_heads = 1
-            dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-            AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=dim_head,
-                use_new_attention_order=use_new_attention_order,
-            ) if not use_spatial_transformer else SpatialTransformer(  # always uses a self-attn
-                            ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim,
-                            disable_self_attn=disable_middle_self_attn, use_linear=use_linear_in_transformer,
-                            use_checkpoint=use_checkpoint
-                        ),
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-        )
-        self._feature_size += ch
-
-        self.output_blocks = nn.ModuleList([])
-        for level, mult in list(enumerate(channel_mult))[::-1]:
-            for i in range(self.num_res_blocks[level] + 1):
-                ich = input_block_chans.pop()
-                layers = [
-                    ResBlock(
-                        ch + ich,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=model_channels * mult,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = model_channels * mult
-                if ds in attention_resolutions:
-                    if num_head_channels == -1:
-                        dim_head = ch // num_heads
-                    else:
-                        num_heads = ch // num_head_channels
-                        dim_head = num_head_channels
-                    if legacy:
-                        #num_heads = 1
-                        dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-                    if exists(disable_self_attentions):
-                        disabled_sa = disable_self_attentions[level]
-                    else:
-                        disabled_sa = False
-
-                    if not exists(num_attention_blocks) or i < num_attention_blocks[level]:
-                        layers.append(
-                            AttentionBlock(
-                                ch,
-                                use_checkpoint=use_checkpoint,
-                                num_heads=num_heads_upsample,
-                                num_head_channels=dim_head,
-                                use_new_attention_order=use_new_attention_order,
-                            ) if not use_spatial_transformer else SpatialTransformer(
-                                ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim,
-                                disable_self_attn=disabled_sa, use_linear=use_linear_in_transformer,
-                                use_checkpoint=use_checkpoint
-                            )
-                        )
-                if level and i == self.num_res_blocks[level]:
-                    out_ch = ch
-                    layers.append(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            up=True,
-                        )
-                        if resblock_updown
-                        else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch)
-                    )
-                    ds //= 2
-                self.output_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-
-        self.out = nn.Sequential(
-            normalization(ch),
-            nn.SiLU(),
-            zero_module(conv_nd(dims, model_channels, out_channels, 3, padding=1)),
-        )
-        if self.predict_codebook_ids:
-            self.id_predictor = nn.Sequential(
-            normalization(ch),
-            conv_nd(dims, model_channels, n_embed, 1),
-            #nn.LogSoftmax(dim=1)  # change to cross_entropy and produce non-normalized logits
-        )
-
-    def convert_to_fp16(self):
-        """
-        Convert the torso of the model to float16.
-        """
-        self.input_blocks.apply(convert_module_to_f16)
-        self.middle_block.apply(convert_module_to_f16)
-        self.output_blocks.apply(convert_module_to_f16)
-
-    def convert_to_fp32(self):
-        """
-        Convert the torso of the model to float32.
-        """
-        self.input_blocks.apply(convert_module_to_f32)
-        self.middle_block.apply(convert_module_to_f32)
-        self.output_blocks.apply(convert_module_to_f32)
-
-    def forward(self, x, timesteps=None, context=None, y=None, features_adapter=None, append_to_context=None, **kwargs):
-        """
-        Apply the model to an input batch.
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps.
-        :param context: conditioning plugged in via crossattn
-        :param y: an [N] Tensor of labels, if class-conditional.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        assert (y is not None) == (
-            self.num_classes is not None
-        ), "must specify y if and only if the model is class-conditional"
-        hs = []
-        t_emb = timestep_embedding(timesteps, self.model_channels, repeat_only=False)
-        emb = self.time_embed(t_emb)
-
-        if self.num_classes is not None:
-            assert y.shape[0] == x.shape[0]
-            emb = emb + self.label_emb(y)
-
-        h = x.type(self.dtype)
-
-        if append_to_context is not None:
-            context = torch.cat([context, append_to_context], dim=1)
-
-        adapter_idx = 0
-        for id, module in enumerate(self.input_blocks):
-            h = module(h, emb, context)
-            if ((id+1)%3 == 0) and features_adapter is not None:
-                h = h + features_adapter[adapter_idx]
-                adapter_idx += 1
-            hs.append(h)
-        if features_adapter is not None:
-            assert len(features_adapter)==adapter_idx, 'Wrong features_adapter'
-
-        h = self.middle_block(h, emb, context)
-        for module in self.output_blocks:
-            h = th.cat([h, hs.pop()], dim=1)
-            h = module(h, emb, context)
-        h = h.type(x.dtype)
-        if self.predict_codebook_ids:
-            return self.id_predictor(h)
-        else:
-            return self.out(h)
diff --git a/spaces/Aditya9790/yolo7-object-tracking/utils/aws/userdata.sh b/spaces/Aditya9790/yolo7-object-tracking/utils/aws/userdata.sh
deleted file mode 100644
index 5a99d4bec7400a08069ce40e8b02928d4b4e06ee..0000000000000000000000000000000000000000
--- a/spaces/Aditya9790/yolo7-object-tracking/utils/aws/userdata.sh
+++ /dev/null
@@ -1,27 +0,0 @@
-#!/bin/bash
-# AWS EC2 instance startup script https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html
-# This script will run only once on first instance start (for a re-start script see mime.sh)
-# /home/ubuntu (ubuntu) or /home/ec2-user (amazon-linux) is working dir
-# Use >300 GB SSD
-
-cd home/ubuntu
-if [ ! -d yolor ]; then
-  echo "Running first-time script." # install dependencies, download COCO, pull Docker
-  git clone -b main https://github.com/WongKinYiu/yolov7 && sudo chmod -R 777 yolov7
-  cd yolov7
-  bash data/scripts/get_coco.sh && echo "Data done." &
-  sudo docker pull nvcr.io/nvidia/pytorch:21.08-py3 && echo "Docker done." &
-  python -m pip install --upgrade pip && pip install -r requirements.txt && python detect.py && echo "Requirements done." &
-  wait && echo "All tasks done." # finish background tasks
-else
-  echo "Running re-start script." # resume interrupted runs
-  i=0
-  list=$(sudo docker ps -qa) # container list i.e. $'one\ntwo\nthree\nfour'
-  while IFS= read -r id; do
-    ((i++))
-    echo "restarting container $i: $id"
-    sudo docker start $id
-    # sudo docker exec -it $id python train.py --resume # single-GPU
-    sudo docker exec -d $id python utils/aws/resume.py # multi-scenario
-  done <<<"$list"
-fi
diff --git a/spaces/Al-Chan/Vits_League_of_Legends_Yuumi_TTS/monotonic_align/core.c b/spaces/Al-Chan/Vits_League_of_Legends_Yuumi_TTS/monotonic_align/core.c
deleted file mode 100644
index 5631d20a9a00db29e143a6e8e4e5c378d6bb850a..0000000000000000000000000000000000000000
--- a/spaces/Al-Chan/Vits_League_of_Legends_Yuumi_TTS/monotonic_align/core.c
+++ /dev/null
@@ -1,21299 +0,0 @@
-/* Generated by Cython 0.29.21 */
-
-/* BEGIN: Cython Metadata
-{
-    "distutils": {
-        "name": "monotonic_align.core",
-        "sources": [
-            "core.pyx"
-        ]
-    },
-    "module_name": "monotonic_align.core"
-}
-END: Cython Metadata */
-
-#define PY_SSIZE_T_CLEAN
-#include "Python.h"
-#ifndef Py_PYTHON_H
-    #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
-#else
-#define CYTHON_ABI "0_29_21"
-#define CYTHON_HEX_VERSION 0x001D15F0
-#define CYTHON_FUTURE_DIVISION 0
-#include <stddef.h>
-#ifndef offsetof
-  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
-#endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
-  #ifndef __stdcall
-    #define __stdcall
-  #endif
-  #ifndef __cdecl
-    #define __cdecl
-  #endif
-  #ifndef __fastcall
-    #define __fastcall
-  #endif
-#endif
-#ifndef DL_IMPORT
-  #define DL_IMPORT(t) t
-#endif
-#ifndef DL_EXPORT
-  #define DL_EXPORT(t) t
-#endif
-#define __PYX_COMMA ,
-#ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
-#endif
-#ifndef PY_LONG_LONG
-  #define PY_LONG_LONG LONG_LONG
-#endif
-#ifndef Py_HUGE_VAL
-  #define Py_HUGE_VAL HUGE_VAL
-#endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
-  #define CYTHON_COMPILING_IN_CPYTHON 0
-  #undef CYTHON_USE_TYPE_SLOTS
-  #define CYTHON_USE_TYPE_SLOTS 0
-  #undef CYTHON_USE_PYTYPE_LOOKUP
-  #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #if PY_VERSION_HEX < 0x03050000
-    #undef CYTHON_USE_ASYNC_SLOTS
-    #define CYTHON_USE_ASYNC_SLOTS 0
-  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
-    #define CYTHON_USE_ASYNC_SLOTS 1
-  #endif
-  #undef CYTHON_USE_PYLIST_INTERNALS
-  #define CYTHON_USE_PYLIST_INTERNALS 0
-  #undef CYTHON_USE_UNICODE_INTERNALS
-  #define CYTHON_USE_UNICODE_INTERNALS 0
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
-  #undef CYTHON_AVOID_BORROWED_REFS
-  #define CYTHON_AVOID_BORROWED_REFS 1
-  #undef CYTHON_ASSUME_SAFE_MACROS
-  #define CYTHON_ASSUME_SAFE_MACROS 0
-  #undef CYTHON_UNPACK_METHODS
-  #define CYTHON_UNPACK_METHODS 0
-  #undef CYTHON_FAST_THREAD_STATE
-  #define CYTHON_FAST_THREAD_STATE 0
-  #undef CYTHON_FAST_PYCALL
-  #define CYTHON_FAST_PYCALL 0
-  #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
-  #undef CYTHON_USE_DICT_VERSIONS
-  #define CYTHON_USE_DICT_VERSIONS 0
-  #undef CYTHON_USE_EXC_INFO_STACK
-  #define CYTHON_USE_EXC_INFO_STACK 0
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
-  #define CYTHON_COMPILING_IN_CPYTHON 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
-  #endif
-  #undef CYTHON_USE_PYTYPE_LOOKUP
-  #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #undef CYTHON_USE_ASYNC_SLOTS
-  #define CYTHON_USE_ASYNC_SLOTS 0
-  #undef CYTHON_USE_PYLIST_INTERNALS
-  #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
-  #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
-  #ifndef CYTHON_AVOID_BORROWED_REFS
-    #define CYTHON_AVOID_BORROWED_REFS 0
-  #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
-  #undef CYTHON_FAST_THREAD_STATE
-  #define CYTHON_FAST_THREAD_STATE 0
-  #undef CYTHON_FAST_PYCALL
-  #define CYTHON_FAST_PYCALL 0
-  #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
-  #undef CYTHON_USE_DICT_VERSIONS
-  #define CYTHON_USE_DICT_VERSIONS 0
-  #undef CYTHON_USE_EXC_INFO_STACK
-  #define CYTHON_USE_EXC_INFO_STACK 0
-#else
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
-  #define CYTHON_COMPILING_IN_CPYTHON 1
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
-  #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
-    #define CYTHON_USE_PYTYPE_LOOKUP 1
-  #endif
-  #if PY_MAJOR_VERSION < 3
-    #undef CYTHON_USE_ASYNC_SLOTS
-    #define CYTHON_USE_ASYNC_SLOTS 0
-  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
-    #define CYTHON_USE_ASYNC_SLOTS 1
-  #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
-    #define CYTHON_USE_PYLONG_INTERNALS 1
-  #endif
-  #ifndef CYTHON_USE_PYLIST_INTERNALS
-    #define CYTHON_USE_PYLIST_INTERNALS 1
-  #endif
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
-  #endif
-  #if PY_VERSION_HEX < 0x030300F0
-    #undef CYTHON_USE_UNICODE_WRITER
-    #define CYTHON_USE_UNICODE_WRITER 0
-  #elif !defined(CYTHON_USE_UNICODE_WRITER)
-    #define CYTHON_USE_UNICODE_WRITER 1
-  #endif
-  #ifndef CYTHON_AVOID_BORROWED_REFS
-    #define CYTHON_AVOID_BORROWED_REFS 0
-  #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
-  #ifndef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 1
-  #endif
-  #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL 1
-  #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
-  #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
-  #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
-  #endif
-  #ifndef CYTHON_USE_EXC_INFO_STACK
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
-  #endif
-#endif
-#if !defined(CYTHON_FAST_PYCCALL)
-#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
-#endif
-#if CYTHON_USE_PYLONG_INTERNALS
-  #include "longintrepr.h"
-  #undef SHIFT
-  #undef BASE
-  #undef MASK
-  #ifdef SIZEOF_VOID_P
-    enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
-  #endif
-#endif
-#ifndef __has_attribute
-  #define __has_attribute(x) 0
-#endif
-#ifndef __has_cpp_attribute
-  #define __has_cpp_attribute(x) 0
-#endif
-#ifndef CYTHON_RESTRICT
-  #if defined(__GNUC__)
-    #define CYTHON_RESTRICT __restrict__
-  #elif defined(_MSC_VER) && _MSC_VER >= 1400
-    #define CYTHON_RESTRICT __restrict
-  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-    #define CYTHON_RESTRICT restrict
-  #else
-    #define CYTHON_RESTRICT
-  #endif
-#endif
-#ifndef CYTHON_UNUSED
-# if defined(__GNUC__)
-#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-#     define CYTHON_UNUSED __attribute__ ((__unused__))
-#   else
-#     define CYTHON_UNUSED
-#   endif
-# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
-#   define CYTHON_UNUSED __attribute__ ((__unused__))
-# else
-#   define CYTHON_UNUSED
-# endif
-#endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
-#  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
-#  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
-#  endif
-#endif
-#ifndef CYTHON_NCP_UNUSED
-# if CYTHON_COMPILING_IN_CPYTHON
-#  define CYTHON_NCP_UNUSED
-# else
-#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
-# endif
-#endif
-#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
-#ifdef _MSC_VER
-    #ifndef _MSC_STDINT_H_
-        #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
-        #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
-        #endif
-    #endif
-#else
-   #include <stdint.h>
-#endif
-#ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
-    #endif
-  #endif
-  #ifndef CYTHON_FALLTHROUGH
-    #if __has_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
-    #else
-      #define CYTHON_FALLTHROUGH
-    #endif
-  #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
-    #if __apple_build_version__ < 7000000
-      #undef  CYTHON_FALLTHROUGH
-      #define CYTHON_FALLTHROUGH
-    #endif
-  #endif
-#endif
-
-#ifndef CYTHON_INLINE
-  #if defined(__clang__)
-    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
-  #elif defined(__GNUC__)
-    #define CYTHON_INLINE __inline__
-  #elif defined(_MSC_VER)
-    #define CYTHON_INLINE __inline
-  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-    #define CYTHON_INLINE inline
-  #else
-    #define CYTHON_INLINE
-  #endif
-#endif
-
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
-#define __PYX_BUILD_PY_SSIZE_T "n"
-#define CYTHON_FORMAT_SSIZE_T "z"
-#if PY_MAJOR_VERSION < 3
-  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
-  #define __Pyx_DefaultClassType PyClass_Type
-#else
-  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
-#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
-#else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
-#endif
-  #define __Pyx_DefaultClassType PyType_Type
-#endif
-#ifndef Py_TPFLAGS_CHECKTYPES
-  #define Py_TPFLAGS_CHECKTYPES 0
-#endif
-#ifndef Py_TPFLAGS_HAVE_INDEX
-  #define Py_TPFLAGS_HAVE_INDEX 0
-#endif
-#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
-  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
-#endif
-#ifndef Py_TPFLAGS_HAVE_FINALIZE
-  #define Py_TPFLAGS_HAVE_FINALIZE 0
-#endif
-#ifndef METH_STACKLESS
-  #define METH_STACKLESS 0
-#endif
-#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
-  #ifndef METH_FASTCALL
-     #define METH_FASTCALL 0x80
-  #endif
-  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
-  typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
-                                                          Py_ssize_t nargs, PyObject *kwnames);
-#else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
-#endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
-#else
-#define __Pyx_PyFastCFunction_Check(func) 0
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
-  #define PyObject_Malloc(s)   PyMem_Malloc(s)
-  #define PyObject_Free(p)     PyMem_Free(p)
-  #define PyObject_Realloc(p)  PyMem_Realloc(p)
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
-#else
-  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
-#endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
-  #define __Pyx_PyThreadState_Current PyThreadState_GET()
-#elif PY_VERSION_HEX >= 0x03060000
-  #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
-#elif PY_VERSION_HEX >= 0x03000000
-  #define __Pyx_PyThreadState_Current PyThreadState_GET()
-#else
-  #define __Pyx_PyThreadState_Current _PyThreadState_Current
-#endif
-#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
-#include "pythread.h"
-#define Py_tss_NEEDS_INIT 0
-typedef int Py_tss_t;
-static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
-  *key = PyThread_create_key();
-  return 0;
-}
-static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
-  Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
-  *key = Py_tss_NEEDS_INIT;
-  return key;
-}
-static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
-  PyObject_Free(key);
-}
-static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
-  return *key != Py_tss_NEEDS_INIT;
-}
-static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
-  PyThread_delete_key(*key);
-  *key = Py_tss_NEEDS_INIT;
-}
-static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
-  return PyThread_set_key_value(*key, value);
-}
-static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
-  return PyThread_get_key_value(*key);
-}
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
-#define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
-#else
-#define __Pyx_PyDict_NewPresized(n)  PyDict_New()
-#endif
-#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
-  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
-  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
-#else
-  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
-  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
-#else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
-#endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
-  #define CYTHON_PEP393_ENABLED 1
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
-  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
-  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
-  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
-  #endif
-#else
-  #define CYTHON_PEP393_ENABLED 0
-  #define PyUnicode_1BYTE_KIND  1
-  #define PyUnicode_2BYTE_KIND  2
-  #define PyUnicode_4BYTE_KIND  4
-  #define __Pyx_PyUnicode_READY(op)       (0)
-  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
-  #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
-  #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
-  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
-#endif
-#if CYTHON_COMPILING_IN_PYPY
-  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
-  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
-#else
-  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
-  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
-      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
-#endif
-#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
-#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
-#else
-  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
-#endif
-#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
-  #define PyObject_ASCII(o)            PyObject_Repr(o)
-#endif
-#if PY_MAJOR_VERSION >= 3
-  #define PyBaseString_Type            PyUnicode_Type
-  #define PyStringObject               PyUnicodeObject
-  #define PyString_Type                PyUnicode_Type
-  #define PyString_Check               PyUnicode_Check
-  #define PyString_CheckExact          PyUnicode_CheckExact
-#ifndef PyObject_Unicode
-  #define PyObject_Unicode             PyObject_Str
-#endif
-#endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
-  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
-#else
-  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
-  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
-#endif
-#ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
-#endif
-#if PY_VERSION_HEX >= 0x030900A4
-  #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
-  #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
-#else
-  #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
-  #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
-#endif
-#if CYTHON_ASSUME_SAFE_MACROS
-  #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
-#else
-  #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
-#endif
-#if PY_MAJOR_VERSION >= 3
-  #define PyIntObject                  PyLongObject
-  #define PyInt_Type                   PyLong_Type
-  #define PyInt_Check(op)              PyLong_Check(op)
-  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
-  #define PyInt_FromString             PyLong_FromString
-  #define PyInt_FromUnicode            PyLong_FromUnicode
-  #define PyInt_FromLong               PyLong_FromLong
-  #define PyInt_FromSize_t             PyLong_FromSize_t
-  #define PyInt_FromSsize_t            PyLong_FromSsize_t
-  #define PyInt_AsLong                 PyLong_AsLong
-  #define PyInt_AS_LONG                PyLong_AS_LONG
-  #define PyInt_AsSsize_t              PyLong_AsSsize_t
-  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
-  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
-  #define PyNumber_Int                 PyNumber_Long
-#endif
-#if PY_MAJOR_VERSION >= 3
-  #define PyBoolObject                 PyLongObject
-#endif
-#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
-  #ifndef PyUnicode_InternFromString
-    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
-  #endif
-#endif
-#if PY_VERSION_HEX < 0x030200A4
-  typedef long Py_hash_t;
-  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
-  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
-#else
-  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
-  #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
-#endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
-#if CYTHON_USE_ASYNC_SLOTS
-  #if PY_VERSION_HEX >= 0x030500B1
-    #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
-    #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
-  #else
-    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
-  #endif
-#else
-  #define __Pyx_PyType_AsAsync(obj) NULL
-#endif
-#ifndef __Pyx_PyAsyncMethodsStruct
-    typedef struct {
-        unaryfunc am_await;
-        unaryfunc am_aiter;
-        unaryfunc am_anext;
-    } __Pyx_PyAsyncMethodsStruct;
-#endif
-
-#if defined(WIN32) || defined(MS_WINDOWS)
-  #define _USE_MATH_DEFINES
-#endif
-#include <math.h>
-#ifdef NAN
-#define __PYX_NAN() ((float) NAN)
-#else
-static CYTHON_INLINE float __PYX_NAN() {
-  float value;
-  memset(&value, 0xFF, sizeof(value));
-  return value;
-}
-#endif
-#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
-#define __Pyx_truncl trunc
-#else
-#define __Pyx_truncl truncl
-#endif
-
-#define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
-#define __PYX_ERR(f_index, lineno, Ln_error) \
-    { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
-
-#ifndef __PYX_EXTERN_C
-  #ifdef __cplusplus
-    #define __PYX_EXTERN_C extern "C"
-  #else
-    #define __PYX_EXTERN_C extern
-  #endif
-#endif
-
-#define __PYX_HAVE__monotonic_align__core
-#define __PYX_HAVE_API__monotonic_align__core
-/* Early includes */
-#include "pythread.h"
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include "pystate.h"
-#ifdef _OPENMP
-#include <omp.h>
-#endif /* _OPENMP */
-
-#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
-#define CYTHON_WITHOUT_ASSERTIONS
-#endif
-
-typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
-                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
-
-#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
-#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
-#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)
-#define __PYX_DEFAULT_STRING_ENCODING ""
-#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
-#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
-#define __Pyx_uchar_cast(c) ((unsigned char)c)
-#define __Pyx_long_cast(x) ((long)x)
-#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
-    (sizeof(type) < sizeof(Py_ssize_t))  ||\
-    (sizeof(type) > sizeof(Py_ssize_t) &&\
-          likely(v < (type)PY_SSIZE_T_MAX ||\
-                 v == (type)PY_SSIZE_T_MAX)  &&\
-          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
-                                v == (type)PY_SSIZE_T_MIN)))  ||\
-    (sizeof(type) == sizeof(Py_ssize_t) &&\
-          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
-                               v == (type)PY_SSIZE_T_MAX)))  )
-static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
-    return (size_t) i < (size_t) limit;
-}
-#if defined (__cplusplus) && __cplusplus >= 201103L
-    #include <cstdlib>
-    #define __Pyx_sst_abs(value) std::abs(value)
-#elif SIZEOF_INT >= SIZEOF_SIZE_T
-    #define __Pyx_sst_abs(value) abs(value)
-#elif SIZEOF_LONG >= SIZEOF_SIZE_T
-    #define __Pyx_sst_abs(value) labs(value)
-#elif defined (_MSC_VER)
-    #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
-#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-    #define __Pyx_sst_abs(value) llabs(value)
-#elif defined (__GNUC__)
-    #define __Pyx_sst_abs(value) __builtin_llabs(value)
-#else
-    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
-#endif
-static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
-static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
-#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
-#define __Pyx_PyBytes_FromString        PyBytes_FromString
-#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
-static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
-#if PY_MAJOR_VERSION < 3
-    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
-    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
-#else
-    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
-    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
-#endif
-#define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
-#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
-#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
-#define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
-#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
-#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
-#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
-#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
-static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
-static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
-static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
-static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
-#define __Pyx_PySequence_Tuple(obj)\
-    (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
-static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
-static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
-#if CYTHON_ASSUME_SAFE_MACROS
-#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
-#else
-#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
-#endif
-#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
-#if PY_MAJOR_VERSION >= 3
-#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
-#else
-#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
-#endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
-#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-static int __Pyx_sys_getdefaultencoding_not_ascii;
-static int __Pyx_init_sys_getdefaultencoding_params(void) {
-    PyObject* sys;
-    PyObject* default_encoding = NULL;
-    PyObject* ascii_chars_u = NULL;
-    PyObject* ascii_chars_b = NULL;
-    const char* default_encoding_c;
-    sys = PyImport_ImportModule("sys");
-    if (!sys) goto bad;
-    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
-    Py_DECREF(sys);
-    if (!default_encoding) goto bad;
-    default_encoding_c = PyBytes_AsString(default_encoding);
-    if (!default_encoding_c) goto bad;
-    if (strcmp(default_encoding_c, "ascii") == 0) {
-        __Pyx_sys_getdefaultencoding_not_ascii = 0;
-    } else {
-        char ascii_chars[128];
-        int c;
-        for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
-        }
-        __Pyx_sys_getdefaultencoding_not_ascii = 1;
-        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
-        if (!ascii_chars_u) goto bad;
-        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
-        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
-            PyErr_Format(
-                PyExc_ValueError,
-                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
-                default_encoding_c);
-            goto bad;
-        }
-        Py_DECREF(ascii_chars_u);
-        Py_DECREF(ascii_chars_b);
-    }
-    Py_DECREF(default_encoding);
-    return 0;
-bad:
-    Py_XDECREF(default_encoding);
-    Py_XDECREF(ascii_chars_u);
-    Py_XDECREF(ascii_chars_b);
-    return -1;
-}
-#endif
-#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
-#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
-#else
-#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
-#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
-static char* __PYX_DEFAULT_STRING_ENCODING;
-static int __Pyx_init_sys_getdefaultencoding_params(void) {
-    PyObject* sys;
-    PyObject* default_encoding = NULL;
-    char* default_encoding_c;
-    sys = PyImport_ImportModule("sys");
-    if (!sys) goto bad;
-    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
-    Py_DECREF(sys);
-    if (!default_encoding) goto bad;
-    default_encoding_c = PyBytes_AsString(default_encoding);
-    if (!default_encoding_c) goto bad;
-    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
-    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
-    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
-    Py_DECREF(default_encoding);
-    return 0;
-bad:
-    Py_XDECREF(default_encoding);
-    return -1;
-}
-#endif
-#endif
-
-
-/* Test for GCC > 2.95 */
-#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
-  #define likely(x)   __builtin_expect(!!(x), 1)
-  #define unlikely(x) __builtin_expect(!!(x), 0)
-#else /* !__GNUC__ or GCC < 2.95 */
-  #define likely(x)   (x)
-  #define unlikely(x) (x)
-#endif /* __GNUC__ */
-static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
-
-static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
-static int __pyx_lineno;
-static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
-static const char *__pyx_filename;
-
-
-static const char *__pyx_f[] = {
-  "core.pyx",
-  "stringsource",
-};
-/* NoFastGil.proto */
-#define __Pyx_PyGILState_Ensure PyGILState_Ensure
-#define __Pyx_PyGILState_Release PyGILState_Release
-#define __Pyx_FastGIL_Remember()
-#define __Pyx_FastGIL_Forget()
-#define __Pyx_FastGilFuncInit()
-
-/* MemviewSliceStruct.proto */
-struct __pyx_memoryview_obj;
-typedef struct {
-  struct __pyx_memoryview_obj *memview;
-  char *data;
-  Py_ssize_t shape[8];
-  Py_ssize_t strides[8];
-  Py_ssize_t suboffsets[8];
-} __Pyx_memviewslice;
-#define __Pyx_MemoryView_Len(m)  (m.shape[0])
-
-/* Atomics.proto */
-#include <pythread.h>
-#ifndef CYTHON_ATOMICS
-    #define CYTHON_ATOMICS 1
-#endif
-#define __pyx_atomic_int_type int
-#if CYTHON_ATOMICS && __GNUC__ >= 4 && (__GNUC_MINOR__ > 1 ||\
-                    (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL >= 2)) &&\
-                    !defined(__i386__)
-    #define __pyx_atomic_incr_aligned(value, lock) __sync_fetch_and_add(value, 1)
-    #define __pyx_atomic_decr_aligned(value, lock) __sync_fetch_and_sub(value, 1)
-    #ifdef __PYX_DEBUG_ATOMICS
-        #warning "Using GNU atomics"
-    #endif
-#elif CYTHON_ATOMICS && defined(_MSC_VER) && 0
-    #include <Windows.h>
-    #undef __pyx_atomic_int_type
-    #define __pyx_atomic_int_type LONG
-    #define __pyx_atomic_incr_aligned(value, lock) InterlockedIncrement(value)
-    #define __pyx_atomic_decr_aligned(value, lock) InterlockedDecrement(value)
-    #ifdef __PYX_DEBUG_ATOMICS
-        #pragma message ("Using MSVC atomics")
-    #endif
-#elif CYTHON_ATOMICS && (defined(__ICC) || defined(__INTEL_COMPILER)) && 0
-    #define __pyx_atomic_incr_aligned(value, lock) _InterlockedIncrement(value)
-    #define __pyx_atomic_decr_aligned(value, lock) _InterlockedDecrement(value)
-    #ifdef __PYX_DEBUG_ATOMICS
-        #warning "Using Intel atomics"
-    #endif
-#else
-    #undef CYTHON_ATOMICS
-    #define CYTHON_ATOMICS 0
-    #ifdef __PYX_DEBUG_ATOMICS
-        #warning "Not using atomics"
-    #endif
-#endif
-typedef volatile __pyx_atomic_int_type __pyx_atomic_int;
-#if CYTHON_ATOMICS
-    #define __pyx_add_acquisition_count(memview)\
-             __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock)
-    #define __pyx_sub_acquisition_count(memview)\
-            __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock)
-#else
-    #define __pyx_add_acquisition_count(memview)\
-            __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
-    #define __pyx_sub_acquisition_count(memview)\
-            __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
-#endif
-
-/* ForceInitThreads.proto */
-#ifndef __PYX_FORCE_INIT_THREADS
-  #define __PYX_FORCE_INIT_THREADS 0
-#endif
-
-/* BufferFormatStructs.proto */
-#define IS_UNSIGNED(type) (((type) -1) > 0)
-struct __Pyx_StructField_;
-#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
-typedef struct {
-  const char* name;
-  struct __Pyx_StructField_* fields;
-  size_t size;
-  size_t arraysize[8];
-  int ndim;
-  char typegroup;
-  char is_unsigned;
-  int flags;
-} __Pyx_TypeInfo;
-typedef struct __Pyx_StructField_ {
-  __Pyx_TypeInfo* type;
-  const char* name;
-  size_t offset;
-} __Pyx_StructField;
-typedef struct {
-  __Pyx_StructField* field;
-  size_t parent_offset;
-} __Pyx_BufFmt_StackElem;
-typedef struct {
-  __Pyx_StructField root;
-  __Pyx_BufFmt_StackElem* head;
-  size_t fmt_offset;
-  size_t new_count, enc_count;
-  size_t struct_alignment;
-  int is_complex;
-  char enc_type;
-  char new_packmode;
-  char enc_packmode;
-  char is_valid_array;
-} __Pyx_BufFmt_Context;
-
-
-/*--- Type declarations ---*/
-struct __pyx_array_obj;
-struct __pyx_MemviewEnum_obj;
-struct __pyx_memoryview_obj;
-struct __pyx_memoryviewslice_obj;
-struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each;
-
-/* "monotonic_align/core.pyx":7
- * @cython.boundscheck(False)
- * @cython.wraparound(False)
- * cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_y, int t_x, float max_neg_val=-1e9) nogil:             # <<<<<<<<<<<<<<
- *   cdef int x
- *   cdef int y
- */
-struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each {
-  int __pyx_n;
-  float max_neg_val;
-};
-
-/* "View.MemoryView":105
- * 
- * @cname("__pyx_array")
- * cdef class array:             # <<<<<<<<<<<<<<
- * 
- *     cdef:
- */
-struct __pyx_array_obj {
-  PyObject_HEAD
-  struct __pyx_vtabstruct_array *__pyx_vtab;
-  char *data;
-  Py_ssize_t len;
-  char *format;
-  int ndim;
-  Py_ssize_t *_shape;
-  Py_ssize_t *_strides;
-  Py_ssize_t itemsize;
-  PyObject *mode;
-  PyObject *_format;
-  void (*callback_free_data)(void *);
-  int free_data;
-  int dtype_is_object;
-};
-
-
-/* "View.MemoryView":279
- * 
- * @cname('__pyx_MemviewEnum')
- * cdef class Enum(object):             # <<<<<<<<<<<<<<
- *     cdef object name
- *     def __init__(self, name):
- */
-struct __pyx_MemviewEnum_obj {
-  PyObject_HEAD
-  PyObject *name;
-};
-
-
-/* "View.MemoryView":330
- * 
- * @cname('__pyx_memoryview')
- * cdef class memoryview(object):             # <<<<<<<<<<<<<<
- * 
- *     cdef object obj
- */
-struct __pyx_memoryview_obj {
-  PyObject_HEAD
-  struct __pyx_vtabstruct_memoryview *__pyx_vtab;
-  PyObject *obj;
-  PyObject *_size;
-  PyObject *_array_interface;
-  PyThread_type_lock lock;
-  __pyx_atomic_int acquisition_count[2];
-  __pyx_atomic_int *acquisition_count_aligned_p;
-  Py_buffer view;
-  int flags;
-  int dtype_is_object;
-  __Pyx_TypeInfo *typeinfo;
-};
-
-
-/* "View.MemoryView":965
- * 
- * @cname('__pyx_memoryviewslice')
- * cdef class _memoryviewslice(memoryview):             # <<<<<<<<<<<<<<
- *     "Internal class for passing memoryview slices to Python"
- * 
- */
-struct __pyx_memoryviewslice_obj {
-  struct __pyx_memoryview_obj __pyx_base;
-  __Pyx_memviewslice from_slice;
-  PyObject *from_object;
-  PyObject *(*to_object_func)(char *);
-  int (*to_dtype_func)(char *, PyObject *);
-};
-
-
-
-/* "View.MemoryView":105
- * 
- * @cname("__pyx_array")
- * cdef class array:             # <<<<<<<<<<<<<<
- * 
- *     cdef:
- */
-
-struct __pyx_vtabstruct_array {
-  PyObject *(*get_memview)(struct __pyx_array_obj *);
-};
-static struct __pyx_vtabstruct_array *__pyx_vtabptr_array;
-
-
-/* "View.MemoryView":330
- * 
- * @cname('__pyx_memoryview')
- * cdef class memoryview(object):             # <<<<<<<<<<<<<<
- * 
- *     cdef object obj
- */
-
-struct __pyx_vtabstruct_memoryview {
-  char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *);
-  PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *);
-  PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *);
-  PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *);
-  PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *);
-  PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *);
-  PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *);
-};
-static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview;
-
-
-/* "View.MemoryView":965
- * 
- * @cname('__pyx_memoryviewslice')
- * cdef class _memoryviewslice(memoryview):             # <<<<<<<<<<<<<<
- *     "Internal class for passing memoryview slices to Python"
- * 
- */
-
-struct __pyx_vtabstruct__memoryviewslice {
-  struct __pyx_vtabstruct_memoryview __pyx_base;
-};
-static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice;
-
-/* --- Runtime support code (head) --- */
-/* Refnanny.proto */
-#ifndef CYTHON_REFNANNY
-  #define CYTHON_REFNANNY 0
-#endif
-#if CYTHON_REFNANNY
-  typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
-    void (*FinishContext)(void**);
-  } __Pyx_RefNannyAPIStruct;
-  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
-  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
-  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
-#ifdef WITH_THREAD
-  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          if (acquire_gil) {\
-              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
-              PyGILState_Release(__pyx_gilstate_save);\
-          } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
-          }
-#else
-  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
-#endif
-  #define __Pyx_RefNannyFinishContext()\
-          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
-#else
-  #define __Pyx_RefNannyDeclarations
-  #define __Pyx_RefNannySetupContext(name, acquire_gil)
-  #define __Pyx_RefNannyFinishContext()
-  #define __Pyx_INCREF(r) Py_INCREF(r)
-  #define __Pyx_DECREF(r) Py_DECREF(r)
-  #define __Pyx_GOTREF(r)
-  #define __Pyx_GIVEREF(r)
-  #define __Pyx_XINCREF(r) Py_XINCREF(r)
-  #define __Pyx_XDECREF(r) Py_XDECREF(r)
-  #define __Pyx_XGOTREF(r)
-  #define __Pyx_XGIVEREF(r)
-#endif
-#define __Pyx_XDECREF_SET(r, v) do {\
-        PyObject *tmp = (PyObject *) r;\
-        r = v; __Pyx_XDECREF(tmp);\
-    } while (0)
-#define __Pyx_DECREF_SET(r, v) do {\
-        PyObject *tmp = (PyObject *) r;\
-        r = v; __Pyx_DECREF(tmp);\
-    } while (0)
-#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
-#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
-
-/* PyObjectGetAttrStr.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
-#endif
-
-/* GetBuiltinName.proto */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name);
-
-/* MemviewSliceInit.proto */
-#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d
-#define __Pyx_MEMVIEW_DIRECT   1
-#define __Pyx_MEMVIEW_PTR      2
-#define __Pyx_MEMVIEW_FULL     4
-#define __Pyx_MEMVIEW_CONTIG   8
-#define __Pyx_MEMVIEW_STRIDED  16
-#define __Pyx_MEMVIEW_FOLLOW   32
-#define __Pyx_IS_C_CONTIG 1
-#define __Pyx_IS_F_CONTIG 2
-static int __Pyx_init_memviewslice(
-                struct __pyx_memoryview_obj *memview,
-                int ndim,
-                __Pyx_memviewslice *memviewslice,
-                int memview_is_new_reference);
-static CYTHON_INLINE int __pyx_add_acquisition_count_locked(
-    __pyx_atomic_int *acquisition_count, PyThread_type_lock lock);
-static CYTHON_INLINE int __pyx_sub_acquisition_count_locked(
-    __pyx_atomic_int *acquisition_count, PyThread_type_lock lock);
-#define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p)
-#define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview))
-#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__)
-#define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__)
-static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int);
-static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *, int, int);
-
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
-/* RaiseDoubleKeywords.proto */
-static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
-
-/* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
-    const char* function_name);
-
-/* None.proto */
-static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname);
-
-/* ArgTypeTest.proto */
-#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
-    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
-        __Pyx__ArgTypeTest(obj, type, name, exact))
-static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
-
-/* PyObjectCall.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
-#else
-#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
-#endif
-
-/* PyThreadStateGet.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
-#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
-#else
-#define __Pyx_PyThreadState_declare
-#define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
-#endif
-
-/* PyErrFetchRestore.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
-#else
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#endif
-#else
-#define __Pyx_PyErr_Clear() PyErr_Clear()
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
-#endif
-
-/* RaiseException.proto */
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
-
-/* PyCFunctionFastCall.proto */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
-#else
-#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
-#endif
-
-/* PyFunctionFastCall.proto */
-#if CYTHON_FAST_PYCALL
-#define __Pyx_PyFunction_FastCall(func, args, nargs)\
-    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
-#if 1 || PY_VERSION_HEX < 0x030600B1
-static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
-#else
-#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
-#endif
-#define __Pyx_BUILD_ASSERT_EXPR(cond)\
-    (sizeof(char [1 - 2*!(cond)]) - 1)
-#ifndef Py_MEMBER_SIZE
-#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
-#endif
-  static size_t __pyx_pyframe_localsplus_offset = 0;
-  #include "frameobject.h"
-  #define __Pxy_PyFrame_Initialize_Offsets()\
-    ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
-     (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
-  #define __Pyx_PyFrame_GetLocalsplus(frame)\
-    (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
-#endif
-
-/* PyObjectCall2Args.proto */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
-
-/* PyObjectCallMethO.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
-#endif
-
-/* PyObjectCallOneArg.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
-
-/* IncludeStringH.proto */
-#include <string.h>
-
-/* BytesEquals.proto */
-static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
-
-/* UnicodeEquals.proto */
-static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
-
-/* StrEquals.proto */
-#if PY_MAJOR_VERSION >= 3
-#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals
-#else
-#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals
-#endif
-
-/* None.proto */
-static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t);
-
-/* UnaryNegOverflows.proto */
-#define UNARY_NEG_WOULD_OVERFLOW(x)\
-        (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x)))
-
-static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
-static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/
-/* GetAttr.proto */
-static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *);
-
-/* GetItemInt.proto */
-#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
-    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
-    __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
-    (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
-               __Pyx_GetItemInt_Generic(o, to_py_func(i))))
-#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
-    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
-    __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
-    (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
-                                                              int wraparound, int boundscheck);
-#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
-    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
-    __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
-    (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
-                                                              int wraparound, int boundscheck);
-static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
-                                                     int is_list, int wraparound, int boundscheck);
-
-/* ObjectGetItem.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key);
-#else
-#define __Pyx_PyObject_GetItem(obj, key)  PyObject_GetItem(obj, key)
-#endif
-
-/* decode_c_string_utf16.proto */
-static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) {
-    int byteorder = 0;
-    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
-}
-static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) {
-    int byteorder = -1;
-    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
-}
-static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) {
-    int byteorder = 1;
-    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
-}
-
-/* decode_c_string.proto */
-static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
-         const char* cstring, Py_ssize_t start, Py_ssize_t stop,
-         const char* encoding, const char* errors,
-         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));
-
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
-#else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
-#endif
-
-/* GetAttr3.proto */
-static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *);
-
-/* PyDictVersioning.proto */
-#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
-#define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
-#define __PYX_GET_DICT_VERSION(dict)  (((PyDictObject*)(dict))->ma_version_tag)
-#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
-    (version_var) = __PYX_GET_DICT_VERSION(dict);\
-    (cache_var) = (value);
-#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
-    static PY_UINT64_T __pyx_dict_version = 0;\
-    static PyObject *__pyx_dict_cached_value = NULL;\
-    if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
-        (VAR) = __pyx_dict_cached_value;\
-    } else {\
-        (VAR) = __pyx_dict_cached_value = (LOOKUP);\
-        __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
-    }\
-}
-static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
-static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
-static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
-#else
-#define __PYX_GET_DICT_VERSION(dict)  (0)
-#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
-#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP)  (VAR) = (LOOKUP);
-#endif
-
-/* GetModuleGlobalName.proto */
-#if CYTHON_USE_DICT_VERSIONS
-#define __Pyx_GetModuleGlobalName(var, name)  {\
-    static PY_UINT64_T __pyx_dict_version = 0;\
-    static PyObject *__pyx_dict_cached_value = NULL;\
-    (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
-        (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
-        __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
-#define __Pyx_GetModuleGlobalNameUncached(var, name)  {\
-    PY_UINT64_T __pyx_dict_version;\
-    PyObject *__pyx_dict_cached_value;\
-    (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
-static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
-#else
-#define __Pyx_GetModuleGlobalName(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
-#define __Pyx_GetModuleGlobalNameUncached(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
-static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
-#endif
-
-/* RaiseTooManyValuesToUnpack.proto */
-static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
-
-/* RaiseNeedMoreValuesToUnpack.proto */
-static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
-
-/* RaiseNoneIterError.proto */
-static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
-
-/* ExtTypeTest.proto */
-static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
-
-/* GetTopmostException.proto */
-#if CYTHON_USE_EXC_INFO_STACK
-static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
-#endif
-
-/* SaveResetException.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
-#else
-#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
-#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
-#endif
-
-/* GetException.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
-static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#else
-static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
-#endif
-
-/* SwapException.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_ExceptionSwap(type, value, tb)  __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#else
-static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
-#endif
-
-/* Import.proto */
-static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
-
-/* FastTypeChecks.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
-static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
-static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
-static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
-#else
-#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
-#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
-#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
-#endif
-#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
-
-static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
-/* ListCompAppend.proto */
-#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
-static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
-    PyListObject* L = (PyListObject*) list;
-    Py_ssize_t len = Py_SIZE(list);
-    if (likely(L->allocated > len)) {
-        Py_INCREF(x);
-        PyList_SET_ITEM(list, len, x);
-        __Pyx_SET_SIZE(list, len + 1);
-        return 0;
-    }
-    return PyList_Append(list, x);
-}
-#else
-#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
-#endif
-
-/* PyIntBinop.proto */
-#if !CYTHON_COMPILING_IN_PYPY
-static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check);
-#else
-#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\
-    (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
-#endif
-
-/* ListExtend.proto */
-static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) {
-#if CYTHON_COMPILING_IN_CPYTHON
-    PyObject* none = _PyList_Extend((PyListObject*)L, v);
-    if (unlikely(!none))
-        return -1;
-    Py_DECREF(none);
-    return 0;
-#else
-    return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v);
-#endif
-}
-
-/* ListAppend.proto */
-#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
-static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
-    PyListObject* L = (PyListObject*) list;
-    Py_ssize_t len = Py_SIZE(list);
-    if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
-        Py_INCREF(x);
-        PyList_SET_ITEM(list, len, x);
-        __Pyx_SET_SIZE(list, len + 1);
-        return 0;
-    }
-    return PyList_Append(list, x);
-}
-#else
-#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
-#endif
-
-/* None.proto */
-static CYTHON_INLINE long __Pyx_div_long(long, long);
-
-/* ImportFrom.proto */
-static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
-
-/* HasAttr.proto */
-static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *);
-
-/* PyObject_GenericGetAttrNoDict.proto */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr
-#endif
-
-/* PyObject_GenericGetAttr.proto */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
-#endif
-
-/* SetVTable.proto */
-static int __Pyx_SetVtable(PyObject *dict, void *vtable);
-
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
-
-/* SetupReduce.proto */
-static int __Pyx_setup_reduce(PyObject* type_obj);
-
-/* CLineInTraceback.proto */
-#ifdef CYTHON_CLINE_IN_TRACEBACK
-#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
-#else
-static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
-#endif
-
-/* CodeObjectCache.proto */
-typedef struct {
-    PyCodeObject* code_object;
-    int code_line;
-} __Pyx_CodeObjectCacheEntry;
-struct __Pyx_CodeObjectCache {
-    int count;
-    int max_count;
-    __Pyx_CodeObjectCacheEntry* entries;
-};
-static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
-static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
-static PyCodeObject *__pyx_find_code_object(int code_line);
-static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
-
-/* AddTraceback.proto */
-static void __Pyx_AddTraceback(const char *funcname, int c_line,
-                               int py_line, const char *filename);
-
-#if PY_MAJOR_VERSION < 3
-    static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
-    static void __Pyx_ReleaseBuffer(Py_buffer *view);
-#else
-    #define __Pyx_GetBuffer PyObject_GetBuffer
-    #define __Pyx_ReleaseBuffer PyBuffer_Release
-#endif
-
-
-/* BufferStructDeclare.proto */
-typedef struct {
-  Py_ssize_t shape, strides, suboffsets;
-} __Pyx_Buf_DimInfo;
-typedef struct {
-  size_t refcount;
-  Py_buffer pybuffer;
-} __Pyx_Buffer;
-typedef struct {
-  __Pyx_Buffer *rcbuffer;
-  char *data;
-  __Pyx_Buf_DimInfo diminfo[8];
-} __Pyx_LocalBuf_ND;
-
-/* MemviewSliceIsContig.proto */
-static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim);
-
-/* OverlappingSlices.proto */
-static int __pyx_slices_overlap(__Pyx_memviewslice *slice1,
-                                __Pyx_memviewslice *slice2,
-                                int ndim, size_t itemsize);
-
-/* Capsule.proto */
-static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig);
-
-/* IsLittleEndian.proto */
-static CYTHON_INLINE int __Pyx_Is_Little_Endian(void);
-
-/* BufferFormatCheck.proto */
-static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
-static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
-                              __Pyx_BufFmt_StackElem* stack,
-                              __Pyx_TypeInfo* type);
-
-/* TypeInfoCompare.proto */
-static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b);
-
-/* MemviewSliceValidateAndInit.proto */
-static int __Pyx_ValidateAndInit_memviewslice(
-                int *axes_specs,
-                int c_or_f_flag,
-                int buf_flags,
-                int ndim,
-                __Pyx_TypeInfo *dtype,
-                __Pyx_BufFmt_StackElem stack[],
-                __Pyx_memviewslice *memviewslice,
-                PyObject *original_obj);
-
-/* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_int(PyObject *, int writable_flag);
-
-/* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_float(PyObject *, int writable_flag);
-
-/* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *, int writable_flag);
-
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
-
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
-
-/* MemviewSliceCopyTemplate.proto */
-static __Pyx_memviewslice
-__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
-                                 const char *mode, int ndim,
-                                 size_t sizeof_dtype, int contig_flag,
-                                 int dtype_is_object);
-
-/* CIntFromPy.proto */
-static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
-
-/* CIntFromPy.proto */
-static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
-
-/* CIntFromPy.proto */
-static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *);
-
-/* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
-
-/* InitStrings.proto */
-static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
-
-static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/
-static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/
-static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/
-static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/
-static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/
-static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/
-static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/
-static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/
-static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/
-static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/
-
-/* Module declarations from 'cython.view' */
-
-/* Module declarations from 'cython' */
-
-/* Module declarations from 'monotonic_align.core' */
-static PyTypeObject *__pyx_array_type = 0;
-static PyTypeObject *__pyx_MemviewEnum_type = 0;
-static PyTypeObject *__pyx_memoryview_type = 0;
-static PyTypeObject *__pyx_memoryviewslice_type = 0;
-static PyObject *generic = 0;
-static PyObject *strided = 0;
-static PyObject *indirect = 0;
-static PyObject *contiguous = 0;
-static PyObject *indirect_contiguous = 0;
-static int __pyx_memoryview_thread_locks_used;
-static PyThread_type_lock __pyx_memoryview_thread_locks[8];
-static void __pyx_f_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice, __Pyx_memviewslice, int, int, struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each *__pyx_optional_args); /*proto*/
-static void __pyx_f_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int __pyx_skip_dispatch); /*proto*/
-static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/
-static void *__pyx_align_pointer(void *, size_t); /*proto*/
-static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/
-static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/
-static PyObject *_unellipsify(PyObject *, int); /*proto*/
-static PyObject *assert_direct_dimensions(Py_ssize_t *, int); /*proto*/
-static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/
-static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/
-static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/
-static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/
-static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/
-static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
-static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
-static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/
-static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
-static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/
-static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/
-static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/
-static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/
-static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/
-static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/
-static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/
-static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/
-static int __pyx_memoryview_err_dim(PyObject *, char *, int); /*proto*/
-static int __pyx_memoryview_err(PyObject *, char *); /*proto*/
-static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/
-static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/
-static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/
-static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/
-static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/
-static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/
-static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/
-static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/
-static __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, IS_UNSIGNED(int) ? 'U' : 'I', IS_UNSIGNED(int), 0 };
-static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 };
-#define __Pyx_MODULE_NAME "monotonic_align.core"
-extern int __pyx_module_is_main_monotonic_align__core;
-int __pyx_module_is_main_monotonic_align__core = 0;
-
-/* Implementation of 'monotonic_align.core' */
-static PyObject *__pyx_builtin_range;
-static PyObject *__pyx_builtin_ValueError;
-static PyObject *__pyx_builtin_MemoryError;
-static PyObject *__pyx_builtin_enumerate;
-static PyObject *__pyx_builtin_TypeError;
-static PyObject *__pyx_builtin_Ellipsis;
-static PyObject *__pyx_builtin_id;
-static PyObject *__pyx_builtin_IndexError;
-static const char __pyx_k_O[] = "O";
-static const char __pyx_k_c[] = "c";
-static const char __pyx_k_id[] = "id";
-static const char __pyx_k_new[] = "__new__";
-static const char __pyx_k_obj[] = "obj";
-static const char __pyx_k_base[] = "base";
-static const char __pyx_k_dict[] = "__dict__";
-static const char __pyx_k_main[] = "__main__";
-static const char __pyx_k_mode[] = "mode";
-static const char __pyx_k_name[] = "name";
-static const char __pyx_k_ndim[] = "ndim";
-static const char __pyx_k_pack[] = "pack";
-static const char __pyx_k_size[] = "size";
-static const char __pyx_k_step[] = "step";
-static const char __pyx_k_stop[] = "stop";
-static const char __pyx_k_t_xs[] = "t_xs";
-static const char __pyx_k_t_ys[] = "t_ys";
-static const char __pyx_k_test[] = "__test__";
-static const char __pyx_k_ASCII[] = "ASCII";
-static const char __pyx_k_class[] = "__class__";
-static const char __pyx_k_error[] = "error";
-static const char __pyx_k_flags[] = "flags";
-static const char __pyx_k_paths[] = "paths";
-static const char __pyx_k_range[] = "range";
-static const char __pyx_k_shape[] = "shape";
-static const char __pyx_k_start[] = "start";
-static const char __pyx_k_encode[] = "encode";
-static const char __pyx_k_format[] = "format";
-static const char __pyx_k_import[] = "__import__";
-static const char __pyx_k_name_2[] = "__name__";
-static const char __pyx_k_pickle[] = "pickle";
-static const char __pyx_k_reduce[] = "__reduce__";
-static const char __pyx_k_struct[] = "struct";
-static const char __pyx_k_unpack[] = "unpack";
-static const char __pyx_k_update[] = "update";
-static const char __pyx_k_values[] = "values";
-static const char __pyx_k_fortran[] = "fortran";
-static const char __pyx_k_memview[] = "memview";
-static const char __pyx_k_Ellipsis[] = "Ellipsis";
-static const char __pyx_k_getstate[] = "__getstate__";
-static const char __pyx_k_itemsize[] = "itemsize";
-static const char __pyx_k_pyx_type[] = "__pyx_type";
-static const char __pyx_k_setstate[] = "__setstate__";
-static const char __pyx_k_TypeError[] = "TypeError";
-static const char __pyx_k_enumerate[] = "enumerate";
-static const char __pyx_k_pyx_state[] = "__pyx_state";
-static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
-static const char __pyx_k_IndexError[] = "IndexError";
-static const char __pyx_k_ValueError[] = "ValueError";
-static const char __pyx_k_pyx_result[] = "__pyx_result";
-static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
-static const char __pyx_k_MemoryError[] = "MemoryError";
-static const char __pyx_k_PickleError[] = "PickleError";
-static const char __pyx_k_pyx_checksum[] = "__pyx_checksum";
-static const char __pyx_k_stringsource[] = "stringsource";
-static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer";
-static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
-static const char __pyx_k_View_MemoryView[] = "View.MemoryView";
-static const char __pyx_k_allocate_buffer[] = "allocate_buffer";
-static const char __pyx_k_dtype_is_object[] = "dtype_is_object";
-static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError";
-static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
-static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum";
-static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
-static const char __pyx_k_strided_and_direct[] = "<strided and direct>";
-static const char __pyx_k_strided_and_indirect[] = "<strided and indirect>";
-static const char __pyx_k_contiguous_and_direct[] = "<contiguous and direct>";
-static const char __pyx_k_MemoryView_of_r_object[] = "<MemoryView of %r object>";
-static const char __pyx_k_MemoryView_of_r_at_0x_x[] = "<MemoryView of %r at 0x%x>";
-static const char __pyx_k_contiguous_and_indirect[] = "<contiguous and indirect>";
-static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'";
-static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d.";
-static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array";
-static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data.";
-static const char __pyx_k_strided_and_direct_or_indirect[] = "<strided and direct or indirect>";
-static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides";
-static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory.";
-static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview";
-static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview";
-static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array";
-static const char __pyx_k_Incompatible_checksums_s_vs_0xb0[] = "Incompatible checksums (%s vs 0xb068931 = (name))";
-static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported";
-static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s";
-static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)";
-static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object";
-static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)";
-static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
-static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides.";
-static PyObject *__pyx_n_s_ASCII;
-static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri;
-static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is;
-static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor;
-static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi;
-static PyObject *__pyx_kp_s_Cannot_index_with_type_s;
-static PyObject *__pyx_n_s_Ellipsis;
-static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr;
-static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xb0;
-static PyObject *__pyx_n_s_IndexError;
-static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte;
-static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr;
-static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d;
-static PyObject *__pyx_n_s_MemoryError;
-static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x;
-static PyObject *__pyx_kp_s_MemoryView_of_r_object;
-static PyObject *__pyx_n_b_O;
-static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a;
-static PyObject *__pyx_n_s_PickleError;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object;
-static PyObject *__pyx_n_s_ValueError;
-static PyObject *__pyx_n_s_View_MemoryView;
-static PyObject *__pyx_n_s_allocate_buffer;
-static PyObject *__pyx_n_s_base;
-static PyObject *__pyx_n_s_c;
-static PyObject *__pyx_n_u_c;
-static PyObject *__pyx_n_s_class;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_kp_s_contiguous_and_direct;
-static PyObject *__pyx_kp_s_contiguous_and_indirect;
-static PyObject *__pyx_n_s_dict;
-static PyObject *__pyx_n_s_dtype_is_object;
-static PyObject *__pyx_n_s_encode;
-static PyObject *__pyx_n_s_enumerate;
-static PyObject *__pyx_n_s_error;
-static PyObject *__pyx_n_s_flags;
-static PyObject *__pyx_n_s_format;
-static PyObject *__pyx_n_s_fortran;
-static PyObject *__pyx_n_u_fortran;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_kp_s_got_differing_extents_in_dimensi;
-static PyObject *__pyx_n_s_id;
-static PyObject *__pyx_n_s_import;
-static PyObject *__pyx_n_s_itemsize;
-static PyObject *__pyx_kp_s_itemsize_0_for_cython_array;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_memview;
-static PyObject *__pyx_n_s_mode;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_n_s_name_2;
-static PyObject *__pyx_n_s_ndim;
-static PyObject *__pyx_n_s_new;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_obj;
-static PyObject *__pyx_n_s_pack;
-static PyObject *__pyx_n_s_paths;
-static PyObject *__pyx_n_s_pickle;
-static PyObject *__pyx_n_s_pyx_PickleError;
-static PyObject *__pyx_n_s_pyx_checksum;
-static PyObject *__pyx_n_s_pyx_getbuffer;
-static PyObject *__pyx_n_s_pyx_result;
-static PyObject *__pyx_n_s_pyx_state;
-static PyObject *__pyx_n_s_pyx_type;
-static PyObject *__pyx_n_s_pyx_unpickle_Enum;
-static PyObject *__pyx_n_s_pyx_vtable;
-static PyObject *__pyx_n_s_range;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_shape;
-static PyObject *__pyx_n_s_size;
-static PyObject *__pyx_n_s_start;
-static PyObject *__pyx_n_s_step;
-static PyObject *__pyx_n_s_stop;
-static PyObject *__pyx_kp_s_strided_and_direct;
-static PyObject *__pyx_kp_s_strided_and_direct_or_indirect;
-static PyObject *__pyx_kp_s_strided_and_indirect;
-static PyObject *__pyx_kp_s_stringsource;
-static PyObject *__pyx_n_s_struct;
-static PyObject *__pyx_n_s_t_xs;
-static PyObject *__pyx_n_s_t_ys;
-static PyObject *__pyx_n_s_test;
-static PyObject *__pyx_kp_s_unable_to_allocate_array_data;
-static PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str;
-static PyObject *__pyx_n_s_unpack;
-static PyObject *__pyx_n_s_update;
-static PyObject *__pyx_n_s_values;
-static PyObject *__pyx_pf_15monotonic_align_4core_maximum_path_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_ys, __Pyx_memviewslice __pyx_v_t_xs); /* proto */
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
-static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */
-static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */
-static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */
-static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
-static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */
-static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */
-static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
-static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
-static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_int_0;
-static PyObject *__pyx_int_1;
-static PyObject *__pyx_int_184977713;
-static PyObject *__pyx_int_neg_1;
-static float __pyx_k_;
-static PyObject *__pyx_tuple__2;
-static PyObject *__pyx_tuple__3;
-static PyObject *__pyx_tuple__4;
-static PyObject *__pyx_tuple__5;
-static PyObject *__pyx_tuple__6;
-static PyObject *__pyx_tuple__7;
-static PyObject *__pyx_tuple__8;
-static PyObject *__pyx_tuple__9;
-static PyObject *__pyx_slice__16;
-static PyObject *__pyx_tuple__10;
-static PyObject *__pyx_tuple__11;
-static PyObject *__pyx_tuple__12;
-static PyObject *__pyx_tuple__13;
-static PyObject *__pyx_tuple__14;
-static PyObject *__pyx_tuple__15;
-static PyObject *__pyx_tuple__17;
-static PyObject *__pyx_tuple__18;
-static PyObject *__pyx_tuple__19;
-static PyObject *__pyx_tuple__20;
-static PyObject *__pyx_tuple__21;
-static PyObject *__pyx_tuple__22;
-static PyObject *__pyx_tuple__23;
-static PyObject *__pyx_tuple__24;
-static PyObject *__pyx_tuple__25;
-static PyObject *__pyx_codeobj__26;
-/* Late includes */
-
-/* "monotonic_align/core.pyx":7
- * @cython.boundscheck(False)
- * @cython.wraparound(False)
- * cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_y, int t_x, float max_neg_val=-1e9) nogil:             # <<<<<<<<<<<<<<
- *   cdef int x
- *   cdef int y
- */
-
-static void __pyx_f_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice __pyx_v_path, __Pyx_memviewslice __pyx_v_value, int __pyx_v_t_y, int __pyx_v_t_x, struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each *__pyx_optional_args) {
-  float __pyx_v_max_neg_val = __pyx_k_;
-  int __pyx_v_x;
-  int __pyx_v_y;
-  float __pyx_v_v_prev;
-  float __pyx_v_v_cur;
-  int __pyx_v_index;
-  int __pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  long __pyx_t_4;
-  int __pyx_t_5;
-  long __pyx_t_6;
-  long __pyx_t_7;
-  int __pyx_t_8;
-  Py_ssize_t __pyx_t_9;
-  Py_ssize_t __pyx_t_10;
-  float __pyx_t_11;
-  float __pyx_t_12;
-  float __pyx_t_13;
-  int __pyx_t_14;
-  Py_ssize_t __pyx_t_15;
-  Py_ssize_t __pyx_t_16;
-  if (__pyx_optional_args) {
-    if (__pyx_optional_args->__pyx_n > 0) {
-      __pyx_v_max_neg_val = __pyx_optional_args->max_neg_val;
-    }
-  }
-
-  /* "monotonic_align/core.pyx":13
- *   cdef float v_cur
- *   cdef float tmp
- *   cdef int index = t_x - 1             # <<<<<<<<<<<<<<
- * 
- *   for y in range(t_y):
- */
-  __pyx_v_index = (__pyx_v_t_x - 1);
-
-  /* "monotonic_align/core.pyx":15
- *   cdef int index = t_x - 1
- * 
- *   for y in range(t_y):             # <<<<<<<<<<<<<<
- *     for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)):
- *       if x == y:
- */
-  __pyx_t_1 = __pyx_v_t_y;
-  __pyx_t_2 = __pyx_t_1;
-  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
-    __pyx_v_y = __pyx_t_3;
-
-    /* "monotonic_align/core.pyx":16
- * 
- *   for y in range(t_y):
- *     for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)):             # <<<<<<<<<<<<<<
- *       if x == y:
- *         v_cur = max_neg_val
- */
-    __pyx_t_4 = (__pyx_v_y + 1);
-    __pyx_t_5 = __pyx_v_t_x;
-    if (((__pyx_t_4 < __pyx_t_5) != 0)) {
-      __pyx_t_6 = __pyx_t_4;
-    } else {
-      __pyx_t_6 = __pyx_t_5;
-    }
-    __pyx_t_4 = __pyx_t_6;
-    __pyx_t_5 = ((__pyx_v_t_x + __pyx_v_y) - __pyx_v_t_y);
-    __pyx_t_6 = 0;
-    if (((__pyx_t_5 > __pyx_t_6) != 0)) {
-      __pyx_t_7 = __pyx_t_5;
-    } else {
-      __pyx_t_7 = __pyx_t_6;
-    }
-    __pyx_t_6 = __pyx_t_4;
-    for (__pyx_t_5 = __pyx_t_7; __pyx_t_5 < __pyx_t_6; __pyx_t_5+=1) {
-      __pyx_v_x = __pyx_t_5;
-
-      /* "monotonic_align/core.pyx":17
- *   for y in range(t_y):
- *     for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)):
- *       if x == y:             # <<<<<<<<<<<<<<
- *         v_cur = max_neg_val
- *       else:
- */
-      __pyx_t_8 = ((__pyx_v_x == __pyx_v_y) != 0);
-      if (__pyx_t_8) {
-
-        /* "monotonic_align/core.pyx":18
- *     for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)):
- *       if x == y:
- *         v_cur = max_neg_val             # <<<<<<<<<<<<<<
- *       else:
- *         v_cur = value[y-1, x]
- */
-        __pyx_v_v_cur = __pyx_v_max_neg_val;
-
-        /* "monotonic_align/core.pyx":17
- *   for y in range(t_y):
- *     for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)):
- *       if x == y:             # <<<<<<<<<<<<<<
- *         v_cur = max_neg_val
- *       else:
- */
-        goto __pyx_L7;
-      }
-
-      /* "monotonic_align/core.pyx":20
- *         v_cur = max_neg_val
- *       else:
- *         v_cur = value[y-1, x]             # <<<<<<<<<<<<<<
- *       if x == 0:
- *         if y == 0:
- */
-      /*else*/ {
-        __pyx_t_9 = (__pyx_v_y - 1);
-        __pyx_t_10 = __pyx_v_x;
-        __pyx_v_v_cur = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_9 * __pyx_v_value.strides[0]) )) + __pyx_t_10)) )));
-      }
-      __pyx_L7:;
-
-      /* "monotonic_align/core.pyx":21
- *       else:
- *         v_cur = value[y-1, x]
- *       if x == 0:             # <<<<<<<<<<<<<<
- *         if y == 0:
- *           v_prev = 0.
- */
-      __pyx_t_8 = ((__pyx_v_x == 0) != 0);
-      if (__pyx_t_8) {
-
-        /* "monotonic_align/core.pyx":22
- *         v_cur = value[y-1, x]
- *       if x == 0:
- *         if y == 0:             # <<<<<<<<<<<<<<
- *           v_prev = 0.
- *         else:
- */
-        __pyx_t_8 = ((__pyx_v_y == 0) != 0);
-        if (__pyx_t_8) {
-
-          /* "monotonic_align/core.pyx":23
- *       if x == 0:
- *         if y == 0:
- *           v_prev = 0.             # <<<<<<<<<<<<<<
- *         else:
- *           v_prev = max_neg_val
- */
-          __pyx_v_v_prev = 0.;
-
-          /* "monotonic_align/core.pyx":22
- *         v_cur = value[y-1, x]
- *       if x == 0:
- *         if y == 0:             # <<<<<<<<<<<<<<
- *           v_prev = 0.
- *         else:
- */
-          goto __pyx_L9;
-        }
-
-        /* "monotonic_align/core.pyx":25
- *           v_prev = 0.
- *         else:
- *           v_prev = max_neg_val             # <<<<<<<<<<<<<<
- *       else:
- *         v_prev = value[y-1, x-1]
- */
-        /*else*/ {
-          __pyx_v_v_prev = __pyx_v_max_neg_val;
-        }
-        __pyx_L9:;
-
-        /* "monotonic_align/core.pyx":21
- *       else:
- *         v_cur = value[y-1, x]
- *       if x == 0:             # <<<<<<<<<<<<<<
- *         if y == 0:
- *           v_prev = 0.
- */
-        goto __pyx_L8;
-      }
-
-      /* "monotonic_align/core.pyx":27
- *           v_prev = max_neg_val
- *       else:
- *         v_prev = value[y-1, x-1]             # <<<<<<<<<<<<<<
- *       value[y, x] += max(v_prev, v_cur)
- * 
- */
-      /*else*/ {
-        __pyx_t_10 = (__pyx_v_y - 1);
-        __pyx_t_9 = (__pyx_v_x - 1);
-        __pyx_v_v_prev = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_10 * __pyx_v_value.strides[0]) )) + __pyx_t_9)) )));
-      }
-      __pyx_L8:;
-
-      /* "monotonic_align/core.pyx":28
- *       else:
- *         v_prev = value[y-1, x-1]
- *       value[y, x] += max(v_prev, v_cur)             # <<<<<<<<<<<<<<
- * 
- *   for y in range(t_y - 1, -1, -1):
- */
-      __pyx_t_11 = __pyx_v_v_cur;
-      __pyx_t_12 = __pyx_v_v_prev;
-      if (((__pyx_t_11 > __pyx_t_12) != 0)) {
-        __pyx_t_13 = __pyx_t_11;
-      } else {
-        __pyx_t_13 = __pyx_t_12;
-      }
-      __pyx_t_9 = __pyx_v_y;
-      __pyx_t_10 = __pyx_v_x;
-      *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_9 * __pyx_v_value.strides[0]) )) + __pyx_t_10)) )) += __pyx_t_13;
-    }
-  }
-
-  /* "monotonic_align/core.pyx":30
- *       value[y, x] += max(v_prev, v_cur)
- * 
- *   for y in range(t_y - 1, -1, -1):             # <<<<<<<<<<<<<<
- *     path[y, index] = 1
- *     if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]):
- */
-  for (__pyx_t_1 = (__pyx_v_t_y - 1); __pyx_t_1 > -1; __pyx_t_1-=1) {
-    __pyx_v_y = __pyx_t_1;
-
-    /* "monotonic_align/core.pyx":31
- * 
- *   for y in range(t_y - 1, -1, -1):
- *     path[y, index] = 1             # <<<<<<<<<<<<<<
- *     if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]):
- *       index = index - 1
- */
-    __pyx_t_10 = __pyx_v_y;
-    __pyx_t_9 = __pyx_v_index;
-    *((int *) ( /* dim=1 */ ((char *) (((int *) ( /* dim=0 */ (__pyx_v_path.data + __pyx_t_10 * __pyx_v_path.strides[0]) )) + __pyx_t_9)) )) = 1;
-
-    /* "monotonic_align/core.pyx":32
- *   for y in range(t_y - 1, -1, -1):
- *     path[y, index] = 1
- *     if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]):             # <<<<<<<<<<<<<<
- *       index = index - 1
- * 
- */
-    __pyx_t_14 = ((__pyx_v_index != 0) != 0);
-    if (__pyx_t_14) {
-    } else {
-      __pyx_t_8 = __pyx_t_14;
-      goto __pyx_L13_bool_binop_done;
-    }
-    __pyx_t_14 = ((__pyx_v_index == __pyx_v_y) != 0);
-    if (!__pyx_t_14) {
-    } else {
-      __pyx_t_8 = __pyx_t_14;
-      goto __pyx_L13_bool_binop_done;
-    }
-    __pyx_t_9 = (__pyx_v_y - 1);
-    __pyx_t_10 = __pyx_v_index;
-    __pyx_t_15 = (__pyx_v_y - 1);
-    __pyx_t_16 = (__pyx_v_index - 1);
-    __pyx_t_14 = (((*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_9 * __pyx_v_value.strides[0]) )) + __pyx_t_10)) ))) < (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_15 * __pyx_v_value.strides[0]) )) + __pyx_t_16)) )))) != 0);
-    __pyx_t_8 = __pyx_t_14;
-    __pyx_L13_bool_binop_done:;
-    if (__pyx_t_8) {
-
-      /* "monotonic_align/core.pyx":33
- *     path[y, index] = 1
- *     if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]):
- *       index = index - 1             # <<<<<<<<<<<<<<
- * 
- * 
- */
-      __pyx_v_index = (__pyx_v_index - 1);
-
-      /* "monotonic_align/core.pyx":32
- *   for y in range(t_y - 1, -1, -1):
- *     path[y, index] = 1
- *     if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]):             # <<<<<<<<<<<<<<
- *       index = index - 1
- * 
- */
-    }
-  }
-
-  /* "monotonic_align/core.pyx":7
- * @cython.boundscheck(False)
- * @cython.wraparound(False)
- * cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_y, int t_x, float max_neg_val=-1e9) nogil:             # <<<<<<<<<<<<<<
- *   cdef int x
- *   cdef int y
- */
-
-  /* function exit code */
-}
-
-/* "monotonic_align/core.pyx":38
- * @cython.boundscheck(False)
- * @cython.wraparound(False)
- * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_ys, int[::1] t_xs) nogil:             # <<<<<<<<<<<<<<
- *   cdef int b = paths.shape[0]
- *   cdef int i
- */
-
-static PyObject *__pyx_pw_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static void __pyx_f_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_ys, __Pyx_memviewslice __pyx_v_t_xs, CYTHON_UNUSED int __pyx_skip_dispatch) {
-  CYTHON_UNUSED int __pyx_v_b;
-  int __pyx_v_i;
-  int __pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  __Pyx_memviewslice __pyx_t_4 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_t_5 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  Py_ssize_t __pyx_t_6;
-  Py_ssize_t __pyx_t_7;
-
-  /* "monotonic_align/core.pyx":39
- * @cython.wraparound(False)
- * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_ys, int[::1] t_xs) nogil:
- *   cdef int b = paths.shape[0]             # <<<<<<<<<<<<<<
- *   cdef int i
- *   for i in prange(b, nogil=True):
- */
-  __pyx_v_b = (__pyx_v_paths.shape[0]);
-
-  /* "monotonic_align/core.pyx":41
- *   cdef int b = paths.shape[0]
- *   cdef int i
- *   for i in prange(b, nogil=True):             # <<<<<<<<<<<<<<
- *     maximum_path_each(paths[i], values[i], t_ys[i], t_xs[i])
- */
-  {
-      #ifdef WITH_THREAD
-      PyThreadState *_save;
-      Py_UNBLOCK_THREADS
-      __Pyx_FastGIL_Remember();
-      #endif
-      /*try:*/ {
-        __pyx_t_1 = __pyx_v_b;
-        if ((1 == 0)) abort();
-        {
-            #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
-                #undef likely
-                #undef unlikely
-                #define likely(x)   (x)
-                #define unlikely(x) (x)
-            #endif
-            __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1;
-            if (__pyx_t_3 > 0)
-            {
-                #ifdef _OPENMP
-                #pragma omp parallel private(__pyx_t_6, __pyx_t_7) firstprivate(__pyx_t_4, __pyx_t_5)
-                #endif /* _OPENMP */
-                {
-                    #ifdef _OPENMP
-                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i)
-                    #endif /* _OPENMP */
-                    for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){
-                        {
-                            __pyx_v_i = (int)(0 + 1 * __pyx_t_2);
-
-                            /* "monotonic_align/core.pyx":42
- *   cdef int i
- *   for i in prange(b, nogil=True):
- *     maximum_path_each(paths[i], values[i], t_ys[i], t_xs[i])             # <<<<<<<<<<<<<<
- */
-                            __pyx_t_4.data = __pyx_v_paths.data;
-                            __pyx_t_4.memview = __pyx_v_paths.memview;
-                            __PYX_INC_MEMVIEW(&__pyx_t_4, 0);
-                            {
-    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_paths.strides[0];
-        __pyx_t_4.data += __pyx_tmp_idx * __pyx_tmp_stride;
-}
-
-__pyx_t_4.shape[0] = __pyx_v_paths.shape[1];
-__pyx_t_4.strides[0] = __pyx_v_paths.strides[1];
-    __pyx_t_4.suboffsets[0] = -1;
-
-__pyx_t_4.shape[1] = __pyx_v_paths.shape[2];
-__pyx_t_4.strides[1] = __pyx_v_paths.strides[2];
-    __pyx_t_4.suboffsets[1] = -1;
-
-__pyx_t_5.data = __pyx_v_values.data;
-                            __pyx_t_5.memview = __pyx_v_values.memview;
-                            __PYX_INC_MEMVIEW(&__pyx_t_5, 0);
-                            {
-    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_values.strides[0];
-        __pyx_t_5.data += __pyx_tmp_idx * __pyx_tmp_stride;
-}
-
-__pyx_t_5.shape[0] = __pyx_v_values.shape[1];
-__pyx_t_5.strides[0] = __pyx_v_values.strides[1];
-    __pyx_t_5.suboffsets[0] = -1;
-
-__pyx_t_5.shape[1] = __pyx_v_values.shape[2];
-__pyx_t_5.strides[1] = __pyx_v_values.strides[2];
-    __pyx_t_5.suboffsets[1] = -1;
-
-__pyx_t_6 = __pyx_v_i;
-                            __pyx_t_7 = __pyx_v_i;
-                            __pyx_f_15monotonic_align_4core_maximum_path_each(__pyx_t_4, __pyx_t_5, (*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_t_ys.data) + __pyx_t_6)) ))), (*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_t_xs.data) + __pyx_t_7)) ))), NULL);
-                            __PYX_XDEC_MEMVIEW(&__pyx_t_4, 0);
-                            __pyx_t_4.memview = NULL;
-                            __pyx_t_4.data = NULL;
-                            __PYX_XDEC_MEMVIEW(&__pyx_t_5, 0);
-                            __pyx_t_5.memview = NULL;
-                            __pyx_t_5.data = NULL;
-                        }
-                    }
-                }
-            }
-        }
-        #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
-            #undef likely
-            #undef unlikely
-            #define likely(x)   __builtin_expect(!!(x), 1)
-            #define unlikely(x) __builtin_expect(!!(x), 0)
-        #endif
-      }
-
-      /* "monotonic_align/core.pyx":41
- *   cdef int b = paths.shape[0]
- *   cdef int i
- *   for i in prange(b, nogil=True):             # <<<<<<<<<<<<<<
- *     maximum_path_each(paths[i], values[i], t_ys[i], t_xs[i])
- */
-      /*finally:*/ {
-        /*normal exit:*/{
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L5;
-        }
-        __pyx_L5:;
-      }
-  }
-
-  /* "monotonic_align/core.pyx":38
- * @cython.boundscheck(False)
- * @cython.wraparound(False)
- * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_ys, int[::1] t_xs) nogil:             # <<<<<<<<<<<<<<
- *   cdef int b = paths.shape[0]
- *   cdef int i
- */
-
-  /* function exit code */
-}
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyObject *__pyx_pw_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  __Pyx_memviewslice __pyx_v_paths = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_values = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_t_ys = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_t_xs = { 0, 0, { 0 }, { 0 }, { 0 } };
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("maximum_path_c (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_paths,&__pyx_n_s_values,&__pyx_n_s_t_ys,&__pyx_n_s_t_xs,0};
-    PyObject* values[4] = {0,0,0,0};
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_paths)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_values)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("maximum_path_c", 1, 4, 4, 1); __PYX_ERR(0, 38, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t_ys)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("maximum_path_c", 1, 4, 4, 2); __PYX_ERR(0, 38, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t_xs)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("maximum_path_c", 1, 4, 4, 3); __PYX_ERR(0, 38, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "maximum_path_c") < 0)) __PYX_ERR(0, 38, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
-    } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-    }
-    __pyx_v_paths = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_int(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_paths.memview)) __PYX_ERR(0, 38, __pyx_L3_error)
-    __pyx_v_values = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_float(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_values.memview)) __PYX_ERR(0, 38, __pyx_L3_error)
-    __pyx_v_t_ys = __Pyx_PyObject_to_MemoryviewSlice_dc_int(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t_ys.memview)) __PYX_ERR(0, 38, __pyx_L3_error)
-    __pyx_v_t_xs = __Pyx_PyObject_to_MemoryviewSlice_dc_int(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t_xs.memview)) __PYX_ERR(0, 38, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("maximum_path_c", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 38, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("monotonic_align.core.maximum_path_c", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_15monotonic_align_4core_maximum_path_c(__pyx_self, __pyx_v_paths, __pyx_v_values, __pyx_v_t_ys, __pyx_v_t_xs);
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15monotonic_align_4core_maximum_path_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_ys, __Pyx_memviewslice __pyx_v_t_xs) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("maximum_path_c", 0);
-  __Pyx_XDECREF(__pyx_r);
-  if (unlikely(!__pyx_v_paths.memview)) { __Pyx_RaiseUnboundLocalError("paths"); __PYX_ERR(0, 38, __pyx_L1_error) }
-  if (unlikely(!__pyx_v_values.memview)) { __Pyx_RaiseUnboundLocalError("values"); __PYX_ERR(0, 38, __pyx_L1_error) }
-  if (unlikely(!__pyx_v_t_ys.memview)) { __Pyx_RaiseUnboundLocalError("t_ys"); __PYX_ERR(0, 38, __pyx_L1_error) }
-  if (unlikely(!__pyx_v_t_xs.memview)) { __Pyx_RaiseUnboundLocalError("t_xs"); __PYX_ERR(0, 38, __pyx_L1_error) }
-  __pyx_t_1 = __Pyx_void_to_None(__pyx_f_15monotonic_align_4core_maximum_path_c(__pyx_v_paths, __pyx_v_values, __pyx_v_t_ys, __pyx_v_t_xs, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("monotonic_align.core.maximum_path_c", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __PYX_XDEC_MEMVIEW(&__pyx_v_paths, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_values, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_t_ys, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_t_xs, 1);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":122
- *         cdef bint dtype_is_object
- * 
- *     def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,             # <<<<<<<<<<<<<<
- *                   mode="c", bint allocate_buffer=True):
- * 
- */
-
-/* Python wrapper */
-static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_shape = 0;
-  Py_ssize_t __pyx_v_itemsize;
-  PyObject *__pyx_v_format = 0;
-  PyObject *__pyx_v_mode = 0;
-  int __pyx_v_allocate_buffer;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0};
-    PyObject* values[5] = {0,0,0,0,0};
-    values[3] = ((PyObject *)__pyx_n_s_c);
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 122, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 122, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 122, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-    }
-    __pyx_v_shape = ((PyObject*)values[0]);
-    __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 122, __pyx_L3_error)
-    __pyx_v_format = values[2];
-    __pyx_v_mode = values[3];
-    if (values[4]) {
-      __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 123, __pyx_L3_error)
-    } else {
-
-      /* "View.MemoryView":123
- * 
- *     def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,
- *                   mode="c", bint allocate_buffer=True):             # <<<<<<<<<<<<<<
- * 
- *         cdef int idx
- */
-      __pyx_v_allocate_buffer = ((int)1);
-    }
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 122, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return -1;
-  __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 122, __pyx_L1_error)
-  if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 122, __pyx_L1_error)
-  }
-  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer);
-
-  /* "View.MemoryView":122
- *         cdef bint dtype_is_object
- * 
- *     def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,             # <<<<<<<<<<<<<<
- *                   mode="c", bint allocate_buffer=True):
- * 
- */
-
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = -1;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) {
-  int __pyx_v_idx;
-  Py_ssize_t __pyx_v_i;
-  Py_ssize_t __pyx_v_dim;
-  PyObject **__pyx_v_p;
-  char __pyx_v_order;
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  Py_ssize_t __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_t_4;
-  PyObject *__pyx_t_5 = NULL;
-  PyObject *__pyx_t_6 = NULL;
-  char *__pyx_t_7;
-  int __pyx_t_8;
-  Py_ssize_t __pyx_t_9;
-  PyObject *__pyx_t_10 = NULL;
-  Py_ssize_t __pyx_t_11;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
-  __Pyx_INCREF(__pyx_v_format);
-
-  /* "View.MemoryView":129
- *         cdef PyObject **p
- * 
- *         self.ndim = <int> len(shape)             # <<<<<<<<<<<<<<
- *         self.itemsize = itemsize
- * 
- */
-  if (unlikely(__pyx_v_shape == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 129, __pyx_L1_error)
-  }
-  __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 129, __pyx_L1_error)
-  __pyx_v_self->ndim = ((int)__pyx_t_1);
-
-  /* "View.MemoryView":130
- * 
- *         self.ndim = <int> len(shape)
- *         self.itemsize = itemsize             # <<<<<<<<<<<<<<
- * 
- *         if not self.ndim:
- */
-  __pyx_v_self->itemsize = __pyx_v_itemsize;
-
-  /* "View.MemoryView":132
- *         self.itemsize = itemsize
- * 
- *         if not self.ndim:             # <<<<<<<<<<<<<<
- *             raise ValueError("Empty shape tuple for cython.array")
- * 
- */
-  __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0);
-  if (unlikely(__pyx_t_2)) {
-
-    /* "View.MemoryView":133
- * 
- *         if not self.ndim:
- *             raise ValueError("Empty shape tuple for cython.array")             # <<<<<<<<<<<<<<
- * 
- *         if itemsize <= 0:
- */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 133, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(1, 133, __pyx_L1_error)
-
-    /* "View.MemoryView":132
- *         self.itemsize = itemsize
- * 
- *         if not self.ndim:             # <<<<<<<<<<<<<<
- *             raise ValueError("Empty shape tuple for cython.array")
- * 
- */
-  }
-
-  /* "View.MemoryView":135
- *             raise ValueError("Empty shape tuple for cython.array")
- * 
- *         if itemsize <= 0:             # <<<<<<<<<<<<<<
- *             raise ValueError("itemsize <= 0 for cython.array")
- * 
- */
-  __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0);
-  if (unlikely(__pyx_t_2)) {
-
-    /* "View.MemoryView":136
- * 
- *         if itemsize <= 0:
- *             raise ValueError("itemsize <= 0 for cython.array")             # <<<<<<<<<<<<<<
- * 
- *         if not isinstance(format, bytes):
- */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 136, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(1, 136, __pyx_L1_error)
-
-    /* "View.MemoryView":135
- *             raise ValueError("Empty shape tuple for cython.array")
- * 
- *         if itemsize <= 0:             # <<<<<<<<<<<<<<
- *             raise ValueError("itemsize <= 0 for cython.array")
- * 
- */
-  }
-
-  /* "View.MemoryView":138
- *             raise ValueError("itemsize <= 0 for cython.array")
- * 
- *         if not isinstance(format, bytes):             # <<<<<<<<<<<<<<
- *             format = format.encode('ASCII')
- *         self._format = format  # keep a reference to the byte string
- */
-  __pyx_t_2 = PyBytes_Check(__pyx_v_format); 
-  __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0);
-  if (__pyx_t_4) {
-
-    /* "View.MemoryView":139
- * 
- *         if not isinstance(format, bytes):
- *             format = format.encode('ASCII')             # <<<<<<<<<<<<<<
- *         self._format = format  # keep a reference to the byte string
- *         self.format = self._format
- */
-    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 139, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_6 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
-      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
-      if (likely(__pyx_t_6)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-        __Pyx_INCREF(__pyx_t_6);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_5, function);
-      }
-    }
-    __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII);
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 139, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3);
-    __pyx_t_3 = 0;
-
-    /* "View.MemoryView":138
- *             raise ValueError("itemsize <= 0 for cython.array")
- * 
- *         if not isinstance(format, bytes):             # <<<<<<<<<<<<<<
- *             format = format.encode('ASCII')
- *         self._format = format  # keep a reference to the byte string
- */
-  }
-
-  /* "View.MemoryView":140
- *         if not isinstance(format, bytes):
- *             format = format.encode('ASCII')
- *         self._format = format  # keep a reference to the byte string             # <<<<<<<<<<<<<<
- *         self.format = self._format
- * 
- */
-  if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(1, 140, __pyx_L1_error)
-  __pyx_t_3 = __pyx_v_format;
-  __Pyx_INCREF(__pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_3);
-  __Pyx_GOTREF(__pyx_v_self->_format);
-  __Pyx_DECREF(__pyx_v_self->_format);
-  __pyx_v_self->_format = ((PyObject*)__pyx_t_3);
-  __pyx_t_3 = 0;
-
-  /* "View.MemoryView":141
- *             format = format.encode('ASCII')
- *         self._format = format  # keep a reference to the byte string
- *         self.format = self._format             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  if (unlikely(__pyx_v_self->_format == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 141, __pyx_L1_error)
-  }
-  __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 141, __pyx_L1_error)
-  __pyx_v_self->format = __pyx_t_7;
-
-  /* "View.MemoryView":144
- * 
- * 
- *         self._shape = <Py_ssize_t *> PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2)             # <<<<<<<<<<<<<<
- *         self._strides = self._shape + self.ndim
- * 
- */
-  __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2)));
-
-  /* "View.MemoryView":145
- * 
- *         self._shape = <Py_ssize_t *> PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2)
- *         self._strides = self._shape + self.ndim             # <<<<<<<<<<<<<<
- * 
- *         if not self._shape:
- */
-  __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim);
-
-  /* "View.MemoryView":147
- *         self._strides = self._shape + self.ndim
- * 
- *         if not self._shape:             # <<<<<<<<<<<<<<
- *             raise MemoryError("unable to allocate shape and strides.")
- * 
- */
-  __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0);
-  if (unlikely(__pyx_t_4)) {
-
-    /* "View.MemoryView":148
- * 
- *         if not self._shape:
- *             raise MemoryError("unable to allocate shape and strides.")             # <<<<<<<<<<<<<<
- * 
- * 
- */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 148, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(1, 148, __pyx_L1_error)
-
-    /* "View.MemoryView":147
- *         self._strides = self._shape + self.ndim
- * 
- *         if not self._shape:             # <<<<<<<<<<<<<<
- *             raise MemoryError("unable to allocate shape and strides.")
- * 
- */
-  }
-
-  /* "View.MemoryView":151
- * 
- * 
- *         for idx, dim in enumerate(shape):             # <<<<<<<<<<<<<<
- *             if dim <= 0:
- *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
- */
-  __pyx_t_8 = 0;
-  __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0;
-  for (;;) {
-    if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
-    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 151, __pyx_L1_error)
-    #else
-    __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 151, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    #endif
-    __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 151, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_v_dim = __pyx_t_9;
-    __pyx_v_idx = __pyx_t_8;
-    __pyx_t_8 = (__pyx_t_8 + 1);
-
-    /* "View.MemoryView":152
- * 
- *         for idx, dim in enumerate(shape):
- *             if dim <= 0:             # <<<<<<<<<<<<<<
- *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
- *             self._shape[idx] = dim
- */
-    __pyx_t_4 = ((__pyx_v_dim <= 0) != 0);
-    if (unlikely(__pyx_t_4)) {
-
-      /* "View.MemoryView":153
- *         for idx, dim in enumerate(shape):
- *             if dim <= 0:
- *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))             # <<<<<<<<<<<<<<
- *             self._shape[idx] = dim
- * 
- */
-      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 153, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 153, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 153, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_10);
-      __Pyx_GIVEREF(__pyx_t_5);
-      PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5);
-      __Pyx_GIVEREF(__pyx_t_6);
-      PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6);
-      __pyx_t_5 = 0;
-      __pyx_t_6 = 0;
-      __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 153, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-      __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 153, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_10);
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      __Pyx_Raise(__pyx_t_10, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-      __PYX_ERR(1, 153, __pyx_L1_error)
-
-      /* "View.MemoryView":152
- * 
- *         for idx, dim in enumerate(shape):
- *             if dim <= 0:             # <<<<<<<<<<<<<<
- *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
- *             self._shape[idx] = dim
- */
-    }
-
-    /* "View.MemoryView":154
- *             if dim <= 0:
- *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
- *             self._shape[idx] = dim             # <<<<<<<<<<<<<<
- * 
- *         cdef char order
- */
-    (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim;
-
-    /* "View.MemoryView":151
- * 
- * 
- *         for idx, dim in enumerate(shape):             # <<<<<<<<<<<<<<
- *             if dim <= 0:
- *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
- */
-  }
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  /* "View.MemoryView":157
- * 
- *         cdef char order
- *         if mode == 'fortran':             # <<<<<<<<<<<<<<
- *             order = b'F'
- *             self.mode = u'fortran'
- */
-  __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 157, __pyx_L1_error)
-  if (__pyx_t_4) {
-
-    /* "View.MemoryView":158
- *         cdef char order
- *         if mode == 'fortran':
- *             order = b'F'             # <<<<<<<<<<<<<<
- *             self.mode = u'fortran'
- *         elif mode == 'c':
- */
-    __pyx_v_order = 'F';
-
-    /* "View.MemoryView":159
- *         if mode == 'fortran':
- *             order = b'F'
- *             self.mode = u'fortran'             # <<<<<<<<<<<<<<
- *         elif mode == 'c':
- *             order = b'C'
- */
-    __Pyx_INCREF(__pyx_n_u_fortran);
-    __Pyx_GIVEREF(__pyx_n_u_fortran);
-    __Pyx_GOTREF(__pyx_v_self->mode);
-    __Pyx_DECREF(__pyx_v_self->mode);
-    __pyx_v_self->mode = __pyx_n_u_fortran;
-
-    /* "View.MemoryView":157
- * 
- *         cdef char order
- *         if mode == 'fortran':             # <<<<<<<<<<<<<<
- *             order = b'F'
- *             self.mode = u'fortran'
- */
-    goto __pyx_L10;
-  }
-
-  /* "View.MemoryView":160
- *             order = b'F'
- *             self.mode = u'fortran'
- *         elif mode == 'c':             # <<<<<<<<<<<<<<
- *             order = b'C'
- *             self.mode = u'c'
- */
-  __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 160, __pyx_L1_error)
-  if (likely(__pyx_t_4)) {
-
-    /* "View.MemoryView":161
- *             self.mode = u'fortran'
- *         elif mode == 'c':
- *             order = b'C'             # <<<<<<<<<<<<<<
- *             self.mode = u'c'
- *         else:
- */
-    __pyx_v_order = 'C';
-
-    /* "View.MemoryView":162
- *         elif mode == 'c':
- *             order = b'C'
- *             self.mode = u'c'             # <<<<<<<<<<<<<<
- *         else:
- *             raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode)
- */
-    __Pyx_INCREF(__pyx_n_u_c);
-    __Pyx_GIVEREF(__pyx_n_u_c);
-    __Pyx_GOTREF(__pyx_v_self->mode);
-    __Pyx_DECREF(__pyx_v_self->mode);
-    __pyx_v_self->mode = __pyx_n_u_c;
-
-    /* "View.MemoryView":160
- *             order = b'F'
- *             self.mode = u'fortran'
- *         elif mode == 'c':             # <<<<<<<<<<<<<<
- *             order = b'C'
- *             self.mode = u'c'
- */
-    goto __pyx_L10;
-  }
-
-  /* "View.MemoryView":164
- *             self.mode = u'c'
- *         else:
- *             raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode)             # <<<<<<<<<<<<<<
- * 
- *         self.len = fill_contig_strides_array(self._shape, self._strides,
- */
-  /*else*/ {
-    __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 164, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 164, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_10);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_Raise(__pyx_t_10, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-    __PYX_ERR(1, 164, __pyx_L1_error)
-  }
-  __pyx_L10:;
-
-  /* "View.MemoryView":166
- *             raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode)
- * 
- *         self.len = fill_contig_strides_array(self._shape, self._strides,             # <<<<<<<<<<<<<<
- *                                              itemsize, self.ndim, order)
- * 
- */
-  __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order);
-
-  /* "View.MemoryView":169
- *                                              itemsize, self.ndim, order)
- * 
- *         self.free_data = allocate_buffer             # <<<<<<<<<<<<<<
- *         self.dtype_is_object = format == b'O'
- *         if allocate_buffer:
- */
-  __pyx_v_self->free_data = __pyx_v_allocate_buffer;
-
-  /* "View.MemoryView":170
- * 
- *         self.free_data = allocate_buffer
- *         self.dtype_is_object = format == b'O'             # <<<<<<<<<<<<<<
- *         if allocate_buffer:
- * 
- */
-  __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 170, __pyx_L1_error)
-  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 170, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-  __pyx_v_self->dtype_is_object = __pyx_t_4;
-
-  /* "View.MemoryView":171
- *         self.free_data = allocate_buffer
- *         self.dtype_is_object = format == b'O'
- *         if allocate_buffer:             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_4 = (__pyx_v_allocate_buffer != 0);
-  if (__pyx_t_4) {
-
-    /* "View.MemoryView":174
- * 
- * 
- *             self.data = <char *>malloc(self.len)             # <<<<<<<<<<<<<<
- *             if not self.data:
- *                 raise MemoryError("unable to allocate array data.")
- */
-    __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len));
-
-    /* "View.MemoryView":175
- * 
- *             self.data = <char *>malloc(self.len)
- *             if not self.data:             # <<<<<<<<<<<<<<
- *                 raise MemoryError("unable to allocate array data.")
- * 
- */
-    __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0);
-    if (unlikely(__pyx_t_4)) {
-
-      /* "View.MemoryView":176
- *             self.data = <char *>malloc(self.len)
- *             if not self.data:
- *                 raise MemoryError("unable to allocate array data.")             # <<<<<<<<<<<<<<
- * 
- *             if self.dtype_is_object:
- */
-      __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 176, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_10);
-      __Pyx_Raise(__pyx_t_10, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-      __PYX_ERR(1, 176, __pyx_L1_error)
-
-      /* "View.MemoryView":175
- * 
- *             self.data = <char *>malloc(self.len)
- *             if not self.data:             # <<<<<<<<<<<<<<
- *                 raise MemoryError("unable to allocate array data.")
- * 
- */
-    }
-
-    /* "View.MemoryView":178
- *                 raise MemoryError("unable to allocate array data.")
- * 
- *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
- *                 p = <PyObject **> self.data
- *                 for i in range(self.len / itemsize):
- */
-    __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0);
-    if (__pyx_t_4) {
-
-      /* "View.MemoryView":179
- * 
- *             if self.dtype_is_object:
- *                 p = <PyObject **> self.data             # <<<<<<<<<<<<<<
- *                 for i in range(self.len / itemsize):
- *                     p[i] = Py_None
- */
-      __pyx_v_p = ((PyObject **)__pyx_v_self->data);
-
-      /* "View.MemoryView":180
- *             if self.dtype_is_object:
- *                 p = <PyObject **> self.data
- *                 for i in range(self.len / itemsize):             # <<<<<<<<<<<<<<
- *                     p[i] = Py_None
- *                     Py_INCREF(Py_None)
- */
-      if (unlikely(__pyx_v_itemsize == 0)) {
-        PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
-        __PYX_ERR(1, 180, __pyx_L1_error)
-      }
-      else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1)  && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) {
-        PyErr_SetString(PyExc_OverflowError, "value too large to perform division");
-        __PYX_ERR(1, 180, __pyx_L1_error)
-      }
-      __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize);
-      __pyx_t_9 = __pyx_t_1;
-      for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) {
-        __pyx_v_i = __pyx_t_11;
-
-        /* "View.MemoryView":181
- *                 p = <PyObject **> self.data
- *                 for i in range(self.len / itemsize):
- *                     p[i] = Py_None             # <<<<<<<<<<<<<<
- *                     Py_INCREF(Py_None)
- * 
- */
-        (__pyx_v_p[__pyx_v_i]) = Py_None;
-
-        /* "View.MemoryView":182
- *                 for i in range(self.len / itemsize):
- *                     p[i] = Py_None
- *                     Py_INCREF(Py_None)             # <<<<<<<<<<<<<<
- * 
- *     @cname('getbuffer')
- */
-        Py_INCREF(Py_None);
-      }
-
-      /* "View.MemoryView":178
- *                 raise MemoryError("unable to allocate array data.")
- * 
- *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
- *                 p = <PyObject **> self.data
- *                 for i in range(self.len / itemsize):
- */
-    }
-
-    /* "View.MemoryView":171
- *         self.free_data = allocate_buffer
- *         self.dtype_is_object = format == b'O'
- *         if allocate_buffer:             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  }
-
-  /* "View.MemoryView":122
- *         cdef bint dtype_is_object
- * 
- *     def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,             # <<<<<<<<<<<<<<
- *                   mode="c", bint allocate_buffer=True):
- * 
- */
-
-  /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_10);
-  __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_format);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":185
- * 
- *     @cname('getbuffer')
- *     def __getbuffer__(self, Py_buffer *info, int flags):             # <<<<<<<<<<<<<<
- *         cdef int bufmode = -1
- *         if self.mode == u"c":
- */
-
-/* Python wrapper */
-static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
-static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
-  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
-  int __pyx_v_bufmode;
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  char *__pyx_t_4;
-  Py_ssize_t __pyx_t_5;
-  int __pyx_t_6;
-  Py_ssize_t *__pyx_t_7;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  if (__pyx_v_info == NULL) {
-    PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
-    return -1;
-  }
-  __Pyx_RefNannySetupContext("__getbuffer__", 0);
-  __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
-  __Pyx_GIVEREF(__pyx_v_info->obj);
-
-  /* "View.MemoryView":186
- *     @cname('getbuffer')
- *     def __getbuffer__(self, Py_buffer *info, int flags):
- *         cdef int bufmode = -1             # <<<<<<<<<<<<<<
- *         if self.mode == u"c":
- *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- */
-  __pyx_v_bufmode = -1;
-
-  /* "View.MemoryView":187
- *     def __getbuffer__(self, Py_buffer *info, int flags):
- *         cdef int bufmode = -1
- *         if self.mode == u"c":             # <<<<<<<<<<<<<<
- *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- *         elif self.mode == u"fortran":
- */
-  __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 187, __pyx_L1_error)
-  __pyx_t_2 = (__pyx_t_1 != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":188
- *         cdef int bufmode = -1
- *         if self.mode == u"c":
- *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS             # <<<<<<<<<<<<<<
- *         elif self.mode == u"fortran":
- *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- */
-    __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS);
-
-    /* "View.MemoryView":187
- *     def __getbuffer__(self, Py_buffer *info, int flags):
- *         cdef int bufmode = -1
- *         if self.mode == u"c":             # <<<<<<<<<<<<<<
- *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- *         elif self.mode == u"fortran":
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":189
- *         if self.mode == u"c":
- *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- *         elif self.mode == u"fortran":             # <<<<<<<<<<<<<<
- *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- *         if not (flags & bufmode):
- */
-  __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 189, __pyx_L1_error)
-  __pyx_t_1 = (__pyx_t_2 != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":190
- *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- *         elif self.mode == u"fortran":
- *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS             # <<<<<<<<<<<<<<
- *         if not (flags & bufmode):
- *             raise ValueError("Can only create a buffer that is contiguous in memory.")
- */
-    __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS);
-
-    /* "View.MemoryView":189
- *         if self.mode == u"c":
- *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- *         elif self.mode == u"fortran":             # <<<<<<<<<<<<<<
- *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- *         if not (flags & bufmode):
- */
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":191
- *         elif self.mode == u"fortran":
- *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- *         if not (flags & bufmode):             # <<<<<<<<<<<<<<
- *             raise ValueError("Can only create a buffer that is contiguous in memory.")
- *         info.buf = self.data
- */
-  __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0);
-  if (unlikely(__pyx_t_1)) {
-
-    /* "View.MemoryView":192
- *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- *         if not (flags & bufmode):
- *             raise ValueError("Can only create a buffer that is contiguous in memory.")             # <<<<<<<<<<<<<<
- *         info.buf = self.data
- *         info.len = self.len
- */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 192, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(1, 192, __pyx_L1_error)
-
-    /* "View.MemoryView":191
- *         elif self.mode == u"fortran":
- *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- *         if not (flags & bufmode):             # <<<<<<<<<<<<<<
- *             raise ValueError("Can only create a buffer that is contiguous in memory.")
- *         info.buf = self.data
- */
-  }
-
-  /* "View.MemoryView":193
- *         if not (flags & bufmode):
- *             raise ValueError("Can only create a buffer that is contiguous in memory.")
- *         info.buf = self.data             # <<<<<<<<<<<<<<
- *         info.len = self.len
- *         info.ndim = self.ndim
- */
-  __pyx_t_4 = __pyx_v_self->data;
-  __pyx_v_info->buf = __pyx_t_4;
-
-  /* "View.MemoryView":194
- *             raise ValueError("Can only create a buffer that is contiguous in memory.")
- *         info.buf = self.data
- *         info.len = self.len             # <<<<<<<<<<<<<<
- *         info.ndim = self.ndim
- *         info.shape = self._shape
- */
-  __pyx_t_5 = __pyx_v_self->len;
-  __pyx_v_info->len = __pyx_t_5;
-
-  /* "View.MemoryView":195
- *         info.buf = self.data
- *         info.len = self.len
- *         info.ndim = self.ndim             # <<<<<<<<<<<<<<
- *         info.shape = self._shape
- *         info.strides = self._strides
- */
-  __pyx_t_6 = __pyx_v_self->ndim;
-  __pyx_v_info->ndim = __pyx_t_6;
-
-  /* "View.MemoryView":196
- *         info.len = self.len
- *         info.ndim = self.ndim
- *         info.shape = self._shape             # <<<<<<<<<<<<<<
- *         info.strides = self._strides
- *         info.suboffsets = NULL
- */
-  __pyx_t_7 = __pyx_v_self->_shape;
-  __pyx_v_info->shape = __pyx_t_7;
-
-  /* "View.MemoryView":197
- *         info.ndim = self.ndim
- *         info.shape = self._shape
- *         info.strides = self._strides             # <<<<<<<<<<<<<<
- *         info.suboffsets = NULL
- *         info.itemsize = self.itemsize
- */
-  __pyx_t_7 = __pyx_v_self->_strides;
-  __pyx_v_info->strides = __pyx_t_7;
-
-  /* "View.MemoryView":198
- *         info.shape = self._shape
- *         info.strides = self._strides
- *         info.suboffsets = NULL             # <<<<<<<<<<<<<<
- *         info.itemsize = self.itemsize
- *         info.readonly = 0
- */
-  __pyx_v_info->suboffsets = NULL;
-
-  /* "View.MemoryView":199
- *         info.strides = self._strides
- *         info.suboffsets = NULL
- *         info.itemsize = self.itemsize             # <<<<<<<<<<<<<<
- *         info.readonly = 0
- * 
- */
-  __pyx_t_5 = __pyx_v_self->itemsize;
-  __pyx_v_info->itemsize = __pyx_t_5;
-
-  /* "View.MemoryView":200
- *         info.suboffsets = NULL
- *         info.itemsize = self.itemsize
- *         info.readonly = 0             # <<<<<<<<<<<<<<
- * 
- *         if flags & PyBUF_FORMAT:
- */
-  __pyx_v_info->readonly = 0;
-
-  /* "View.MemoryView":202
- *         info.readonly = 0
- * 
- *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
- *             info.format = self.format
- *         else:
- */
-  __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":203
- * 
- *         if flags & PyBUF_FORMAT:
- *             info.format = self.format             # <<<<<<<<<<<<<<
- *         else:
- *             info.format = NULL
- */
-    __pyx_t_4 = __pyx_v_self->format;
-    __pyx_v_info->format = __pyx_t_4;
-
-    /* "View.MemoryView":202
- *         info.readonly = 0
- * 
- *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
- *             info.format = self.format
- *         else:
- */
-    goto __pyx_L5;
-  }
-
-  /* "View.MemoryView":205
- *             info.format = self.format
- *         else:
- *             info.format = NULL             # <<<<<<<<<<<<<<
- * 
- *         info.obj = self
- */
-  /*else*/ {
-    __pyx_v_info->format = NULL;
-  }
-  __pyx_L5:;
-
-  /* "View.MemoryView":207
- *             info.format = NULL
- * 
- *         info.obj = self             # <<<<<<<<<<<<<<
- * 
- *     __pyx_getbuffer = capsule(<void *> &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")
- */
-  __Pyx_INCREF(((PyObject *)__pyx_v_self));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
-  __Pyx_GOTREF(__pyx_v_info->obj);
-  __Pyx_DECREF(__pyx_v_info->obj);
-  __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
-
-  /* "View.MemoryView":185
- * 
- *     @cname('getbuffer')
- *     def __getbuffer__(self, Py_buffer *info, int flags):             # <<<<<<<<<<<<<<
- *         cdef int bufmode = -1
- *         if self.mode == u"c":
- */
-
-  /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  if (__pyx_v_info->obj != NULL) {
-    __Pyx_GOTREF(__pyx_v_info->obj);
-    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
-  }
-  goto __pyx_L2;
-  __pyx_L0:;
-  if (__pyx_v_info->obj == Py_None) {
-    __Pyx_GOTREF(__pyx_v_info->obj);
-    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
-  }
-  __pyx_L2:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":211
- *     __pyx_getbuffer = capsule(<void *> &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")
- * 
- *     def __dealloc__(array self):             # <<<<<<<<<<<<<<
- *         if self.callback_free_data != NULL:
- *             self.callback_free_data(self.data)
- */
-
-/* Python wrapper */
-static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/
-static void __pyx_array___dealloc__(PyObject *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
-  __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
-
-  /* "View.MemoryView":212
- * 
- *     def __dealloc__(array self):
- *         if self.callback_free_data != NULL:             # <<<<<<<<<<<<<<
- *             self.callback_free_data(self.data)
- *         elif self.free_data:
- */
-  __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":213
- *     def __dealloc__(array self):
- *         if self.callback_free_data != NULL:
- *             self.callback_free_data(self.data)             # <<<<<<<<<<<<<<
- *         elif self.free_data:
- *             if self.dtype_is_object:
- */
-    __pyx_v_self->callback_free_data(__pyx_v_self->data);
-
-    /* "View.MemoryView":212
- * 
- *     def __dealloc__(array self):
- *         if self.callback_free_data != NULL:             # <<<<<<<<<<<<<<
- *             self.callback_free_data(self.data)
- *         elif self.free_data:
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":214
- *         if self.callback_free_data != NULL:
- *             self.callback_free_data(self.data)
- *         elif self.free_data:             # <<<<<<<<<<<<<<
- *             if self.dtype_is_object:
- *                 refcount_objects_in_slice(self.data, self._shape,
- */
-  __pyx_t_1 = (__pyx_v_self->free_data != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":215
- *             self.callback_free_data(self.data)
- *         elif self.free_data:
- *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
- *                 refcount_objects_in_slice(self.data, self._shape,
- *                                           self._strides, self.ndim, False)
- */
-    __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0);
-    if (__pyx_t_1) {
-
-      /* "View.MemoryView":216
- *         elif self.free_data:
- *             if self.dtype_is_object:
- *                 refcount_objects_in_slice(self.data, self._shape,             # <<<<<<<<<<<<<<
- *                                           self._strides, self.ndim, False)
- *             free(self.data)
- */
-      __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0);
-
-      /* "View.MemoryView":215
- *             self.callback_free_data(self.data)
- *         elif self.free_data:
- *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
- *                 refcount_objects_in_slice(self.data, self._shape,
- *                                           self._strides, self.ndim, False)
- */
-    }
-
-    /* "View.MemoryView":218
- *                 refcount_objects_in_slice(self.data, self._shape,
- *                                           self._strides, self.ndim, False)
- *             free(self.data)             # <<<<<<<<<<<<<<
- *         PyObject_Free(self._shape)
- * 
- */
-    free(__pyx_v_self->data);
-
-    /* "View.MemoryView":214
- *         if self.callback_free_data != NULL:
- *             self.callback_free_data(self.data)
- *         elif self.free_data:             # <<<<<<<<<<<<<<
- *             if self.dtype_is_object:
- *                 refcount_objects_in_slice(self.data, self._shape,
- */
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":219
- *                                           self._strides, self.ndim, False)
- *             free(self.data)
- *         PyObject_Free(self._shape)             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  PyObject_Free(__pyx_v_self->_shape);
-
-  /* "View.MemoryView":211
- *     __pyx_getbuffer = capsule(<void *> &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")
- * 
- *     def __dealloc__(array self):             # <<<<<<<<<<<<<<
- *         if self.callback_free_data != NULL:
- *             self.callback_free_data(self.data)
- */
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-/* "View.MemoryView":222
- * 
- *     @property
- *     def memview(self):             # <<<<<<<<<<<<<<
- *         return self.get_memview()
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "View.MemoryView":223
- *     @property
- *     def memview(self):
- *         return self.get_memview()             # <<<<<<<<<<<<<<
- * 
- *     @cname('get_memview')
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 223, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":222
- * 
- *     @property
- *     def memview(self):             # <<<<<<<<<<<<<<
- *         return self.get_memview()
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":226
- * 
- *     @cname('get_memview')
- *     cdef get_memview(self):             # <<<<<<<<<<<<<<
- *         flags =  PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
- *         return  memoryview(self, flags, self.dtype_is_object)
- */
-
-static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) {
-  int __pyx_v_flags;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("get_memview", 0);
-
-  /* "View.MemoryView":227
- *     @cname('get_memview')
- *     cdef get_memview(self):
- *         flags =  PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE             # <<<<<<<<<<<<<<
- *         return  memoryview(self, flags, self.dtype_is_object)
- * 
- */
-  __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE);
-
-  /* "View.MemoryView":228
- *     cdef get_memview(self):
- *         flags =  PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
- *         return  memoryview(self, flags, self.dtype_is_object)             # <<<<<<<<<<<<<<
- * 
- *     def __len__(self):
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 228, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 228, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 228, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_INCREF(((PyObject *)__pyx_v_self));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
-  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
-  __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 228, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":226
- * 
- *     @cname('get_memview')
- *     cdef get_memview(self):             # <<<<<<<<<<<<<<
- *         flags =  PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
- *         return  memoryview(self, flags, self.dtype_is_object)
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":230
- *         return  memoryview(self, flags, self.dtype_is_object)
- * 
- *     def __len__(self):             # <<<<<<<<<<<<<<
- *         return self._shape[0]
- * 
- */
-
-/* Python wrapper */
-static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/
-static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) {
-  Py_ssize_t __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__len__ (wrapper)", 0);
-  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) {
-  Py_ssize_t __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__len__", 0);
-
-  /* "View.MemoryView":231
- * 
- *     def __len__(self):
- *         return self._shape[0]             # <<<<<<<<<<<<<<
- * 
- *     def __getattr__(self, attr):
- */
-  __pyx_r = (__pyx_v_self->_shape[0]);
-  goto __pyx_L0;
-
-  /* "View.MemoryView":230
- *         return  memoryview(self, flags, self.dtype_is_object)
- * 
- *     def __len__(self):             # <<<<<<<<<<<<<<
- *         return self._shape[0]
- * 
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":233
- *         return self._shape[0]
- * 
- *     def __getattr__(self, attr):             # <<<<<<<<<<<<<<
- *         return getattr(self.memview, attr)
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/
-static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0);
-  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__getattr__", 0);
-
-  /* "View.MemoryView":234
- * 
- *     def __getattr__(self, attr):
- *         return getattr(self.memview, attr)             # <<<<<<<<<<<<<<
- * 
- *     def __getitem__(self, item):
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 234, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 234, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":233
- *         return self._shape[0]
- * 
- *     def __getattr__(self, attr):             # <<<<<<<<<<<<<<
- *         return getattr(self.memview, attr)
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":236
- *         return getattr(self.memview, attr)
- * 
- *     def __getitem__(self, item):             # <<<<<<<<<<<<<<
- *         return self.memview[item]
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/
-static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
-  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__getitem__", 0);
-
-  /* "View.MemoryView":237
- * 
- *     def __getitem__(self, item):
- *         return self.memview[item]             # <<<<<<<<<<<<<<
- * 
- *     def __setitem__(self, item, value):
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 237, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 237, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":236
- *         return getattr(self.memview, attr)
- * 
- *     def __getitem__(self, item):             # <<<<<<<<<<<<<<
- *         return self.memview[item]
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":239
- *         return self.memview[item]
- * 
- *     def __setitem__(self, item, value):             # <<<<<<<<<<<<<<
- *         self.memview[item] = value
- * 
- */
-
-/* Python wrapper */
-static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/
-static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
-  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setitem__", 0);
-
-  /* "View.MemoryView":240
- * 
- *     def __setitem__(self, item, value):
- *         self.memview[item] = value             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 240, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0)) __PYX_ERR(1, 240, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  /* "View.MemoryView":239
- *         return self.memview[item]
- * 
- *     def __setitem__(self, item, value):             # <<<<<<<<<<<<<<
- *         self.memview[item] = value
- * 
- */
-
-  /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
-
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(1, 2, __pyx_L1_error)
-
-  /* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(1, 4, __pyx_L1_error)
-
-  /* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":244
- * 
- * @cname("__pyx_array_new")
- * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format,             # <<<<<<<<<<<<<<
- *                           char *mode, char *buf):
- *     cdef array result
- */
-
-static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) {
-  struct __pyx_array_obj *__pyx_v_result = 0;
-  struct __pyx_array_obj *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("array_cwrapper", 0);
-
-  /* "View.MemoryView":248
- *     cdef array result
- * 
- *     if buf == NULL:             # <<<<<<<<<<<<<<
- *         result = array(shape, itemsize, format, mode.decode('ASCII'))
- *     else:
- */
-  __pyx_t_1 = ((__pyx_v_buf == NULL) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":249
- * 
- *     if buf == NULL:
- *         result = array(shape, itemsize, format, mode.decode('ASCII'))             # <<<<<<<<<<<<<<
- *     else:
- *         result = array(shape, itemsize, format, mode.decode('ASCII'),
- */
-    __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 249, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 249, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 249, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __Pyx_INCREF(__pyx_v_shape);
-    __Pyx_GIVEREF(__pyx_v_shape);
-    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape);
-    __Pyx_GIVEREF(__pyx_t_2);
-    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2);
-    __Pyx_GIVEREF(__pyx_t_3);
-    PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3);
-    __Pyx_GIVEREF(__pyx_t_4);
-    PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4);
-    __pyx_t_2 = 0;
-    __pyx_t_3 = 0;
-    __pyx_t_4 = 0;
-    __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4);
-    __pyx_t_4 = 0;
-
-    /* "View.MemoryView":248
- *     cdef array result
- * 
- *     if buf == NULL:             # <<<<<<<<<<<<<<
- *         result = array(shape, itemsize, format, mode.decode('ASCII'))
- *     else:
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":251
- *         result = array(shape, itemsize, format, mode.decode('ASCII'))
- *     else:
- *         result = array(shape, itemsize, format, mode.decode('ASCII'),             # <<<<<<<<<<<<<<
- *                        allocate_buffer=False)
- *         result.data = buf
- */
-  /*else*/ {
-    __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 251, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 251, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 251, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 251, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_INCREF(__pyx_v_shape);
-    __Pyx_GIVEREF(__pyx_v_shape);
-    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape);
-    __Pyx_GIVEREF(__pyx_t_4);
-    PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4);
-    __Pyx_GIVEREF(__pyx_t_5);
-    PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5);
-    __Pyx_GIVEREF(__pyx_t_3);
-    PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3);
-    __pyx_t_4 = 0;
-    __pyx_t_5 = 0;
-    __pyx_t_3 = 0;
-
-    /* "View.MemoryView":252
- *     else:
- *         result = array(shape, itemsize, format, mode.decode('ASCII'),
- *                        allocate_buffer=False)             # <<<<<<<<<<<<<<
- *         result.data = buf
- * 
- */
-    __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 252, __pyx_L1_error)
-
-    /* "View.MemoryView":251
- *         result = array(shape, itemsize, format, mode.decode('ASCII'))
- *     else:
- *         result = array(shape, itemsize, format, mode.decode('ASCII'),             # <<<<<<<<<<<<<<
- *                        allocate_buffer=False)
- *         result.data = buf
- */
-    __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 251, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5);
-    __pyx_t_5 = 0;
-
-    /* "View.MemoryView":253
- *         result = array(shape, itemsize, format, mode.decode('ASCII'),
- *                        allocate_buffer=False)
- *         result.data = buf             # <<<<<<<<<<<<<<
- * 
- *     return result
- */
-    __pyx_v_result->data = __pyx_v_buf;
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":255
- *         result.data = buf
- * 
- *     return result             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __Pyx_XDECREF(((PyObject *)__pyx_r));
-  __Pyx_INCREF(((PyObject *)__pyx_v_result));
-  __pyx_r = __pyx_v_result;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":244
- * 
- * @cname("__pyx_array_new")
- * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format,             # <<<<<<<<<<<<<<
- *                           char *mode, char *buf):
- *     cdef array result
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_result);
-  __Pyx_XGIVEREF((PyObject *)__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":281
- * cdef class Enum(object):
- *     cdef object name
- *     def __init__(self, name):             # <<<<<<<<<<<<<<
- *         self.name = name
- *     def __repr__(self):
- */
-
-/* Python wrapper */
-static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_name = 0;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 281, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
-      goto __pyx_L5_argtuple_error;
-    } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-    }
-    __pyx_v_name = values[0];
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 281, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return -1;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name);
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__init__", 0);
-
-  /* "View.MemoryView":282
- *     cdef object name
- *     def __init__(self, name):
- *         self.name = name             # <<<<<<<<<<<<<<
- *     def __repr__(self):
- *         return self.name
- */
-  __Pyx_INCREF(__pyx_v_name);
-  __Pyx_GIVEREF(__pyx_v_name);
-  __Pyx_GOTREF(__pyx_v_self->name);
-  __Pyx_DECREF(__pyx_v_self->name);
-  __pyx_v_self->name = __pyx_v_name;
-
-  /* "View.MemoryView":281
- * cdef class Enum(object):
- *     cdef object name
- *     def __init__(self, name):             # <<<<<<<<<<<<<<
- *         self.name = name
- *     def __repr__(self):
- */
-
-  /* function exit code */
-  __pyx_r = 0;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":283
- *     def __init__(self, name):
- *         self.name = name
- *     def __repr__(self):             # <<<<<<<<<<<<<<
- *         return self.name
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
-  __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__repr__", 0);
-
-  /* "View.MemoryView":284
- *         self.name = name
- *     def __repr__(self):
- *         return self.name             # <<<<<<<<<<<<<<
- * 
- * cdef generic = Enum("<strided and direct or indirect>")
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_self->name);
-  __pyx_r = __pyx_v_self->name;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":283
- *     def __init__(self, name):
- *         self.name = name
- *     def __repr__(self):             # <<<<<<<<<<<<<<
- *         return self.name
- * 
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     cdef tuple state
- *     cdef object _dict
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) {
-  PyObject *__pyx_v_state = 0;
-  PyObject *__pyx_v__dict = 0;
-  int __pyx_v_use_setstate;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
-
-  /* "(tree fragment)":5
- *     cdef object _dict
- *     cdef bint use_setstate
- *     state = (self.name,)             # <<<<<<<<<<<<<<
- *     _dict = getattr(self, '__dict__', None)
- *     if _dict is not None:
- */
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(__pyx_v_self->name);
-  __Pyx_GIVEREF(__pyx_v_self->name);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name);
-  __pyx_v_state = ((PyObject*)__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  /* "(tree fragment)":6
- *     cdef bint use_setstate
- *     state = (self.name,)
- *     _dict = getattr(self, '__dict__', None)             # <<<<<<<<<<<<<<
- *     if _dict is not None:
- *         state += (_dict,)
- */
-  __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v__dict = __pyx_t_1;
-  __pyx_t_1 = 0;
-
-  /* "(tree fragment)":7
- *     state = (self.name,)
- *     _dict = getattr(self, '__dict__', None)
- *     if _dict is not None:             # <<<<<<<<<<<<<<
- *         state += (_dict,)
- *         use_setstate = True
- */
-  __pyx_t_2 = (__pyx_v__dict != Py_None);
-  __pyx_t_3 = (__pyx_t_2 != 0);
-  if (__pyx_t_3) {
-
-    /* "(tree fragment)":8
- *     _dict = getattr(self, '__dict__', None)
- *     if _dict is not None:
- *         state += (_dict,)             # <<<<<<<<<<<<<<
- *         use_setstate = True
- *     else:
- */
-    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_INCREF(__pyx_v__dict);
-    __Pyx_GIVEREF(__pyx_v__dict);
-    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict);
-    __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4));
-    __pyx_t_4 = 0;
-
-    /* "(tree fragment)":9
- *     if _dict is not None:
- *         state += (_dict,)
- *         use_setstate = True             # <<<<<<<<<<<<<<
- *     else:
- *         use_setstate = self.name is not None
- */
-    __pyx_v_use_setstate = 1;
-
-    /* "(tree fragment)":7
- *     state = (self.name,)
- *     _dict = getattr(self, '__dict__', None)
- *     if _dict is not None:             # <<<<<<<<<<<<<<
- *         state += (_dict,)
- *         use_setstate = True
- */
-    goto __pyx_L3;
-  }
-
-  /* "(tree fragment)":11
- *         use_setstate = True
- *     else:
- *         use_setstate = self.name is not None             # <<<<<<<<<<<<<<
- *     if use_setstate:
- *         return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
- */
-  /*else*/ {
-    __pyx_t_3 = (__pyx_v_self->name != Py_None);
-    __pyx_v_use_setstate = __pyx_t_3;
-  }
-  __pyx_L3:;
-
-  /* "(tree fragment)":12
- *     else:
- *         use_setstate = self.name is not None
- *     if use_setstate:             # <<<<<<<<<<<<<<
- *         return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
- *     else:
- */
-  __pyx_t_3 = (__pyx_v_use_setstate != 0);
-  if (__pyx_t_3) {
-
-    /* "(tree fragment)":13
- *         use_setstate = self.name is not None
- *     if use_setstate:
- *         return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state             # <<<<<<<<<<<<<<
- *     else:
- *         return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
- */
-    __Pyx_XDECREF(__pyx_r);
-    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
-    __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
-    PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
-    __Pyx_INCREF(__pyx_int_184977713);
-    __Pyx_GIVEREF(__pyx_int_184977713);
-    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713);
-    __Pyx_INCREF(Py_None);
-    __Pyx_GIVEREF(Py_None);
-    PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None);
-    __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __Pyx_GIVEREF(__pyx_t_4);
-    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
-    __Pyx_GIVEREF(__pyx_t_1);
-    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
-    __Pyx_INCREF(__pyx_v_state);
-    __Pyx_GIVEREF(__pyx_v_state);
-    PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state);
-    __pyx_t_4 = 0;
-    __pyx_t_1 = 0;
-    __pyx_r = __pyx_t_5;
-    __pyx_t_5 = 0;
-    goto __pyx_L0;
-
-    /* "(tree fragment)":12
- *     else:
- *         use_setstate = self.name is not None
- *     if use_setstate:             # <<<<<<<<<<<<<<
- *         return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
- *     else:
- */
-  }
-
-  /* "(tree fragment)":15
- *         return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
- *     else:
- *         return __pyx_unpickle_Enum, (type(self), 0xb068931, state)             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     __pyx_unpickle_Enum__set_state(self, __pyx_state)
- */
-  /*else*/ {
-    __Pyx_XDECREF(__pyx_r);
-    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
-    __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
-    PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
-    __Pyx_INCREF(__pyx_int_184977713);
-    __Pyx_GIVEREF(__pyx_int_184977713);
-    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713);
-    __Pyx_INCREF(__pyx_v_state);
-    __Pyx_GIVEREF(__pyx_v_state);
-    PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state);
-    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_GIVEREF(__pyx_t_5);
-    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
-    __Pyx_GIVEREF(__pyx_t_1);
-    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
-    __pyx_t_5 = 0;
-    __pyx_t_1 = 0;
-    __pyx_r = __pyx_t_4;
-    __pyx_t_4 = 0;
-    goto __pyx_L0;
-  }
-
-  /* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     cdef tuple state
- *     cdef object _dict
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_state);
-  __Pyx_XDECREF(__pyx_v__dict);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "(tree fragment)":16
- *     else:
- *         return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     __pyx_unpickle_Enum__set_state(self, __pyx_state)
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
-
-  /* "(tree fragment)":17
- *         return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
- * def __setstate_cython__(self, __pyx_state):
- *     __pyx_unpickle_Enum__set_state(self, __pyx_state)             # <<<<<<<<<<<<<<
- */
-  if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error)
-  __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  /* "(tree fragment)":16
- *     else:
- *         return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     __pyx_unpickle_Enum__set_state(self, __pyx_state)
- */
-
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":298
- * 
- * @cname('__pyx_align_pointer')
- * cdef void *align_pointer(void *memory, size_t alignment) nogil:             # <<<<<<<<<<<<<<
- *     "Align pointer memory on a given boundary"
- *     cdef Py_intptr_t aligned_p = <Py_intptr_t> memory
- */
-
-static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) {
-  Py_intptr_t __pyx_v_aligned_p;
-  size_t __pyx_v_offset;
-  void *__pyx_r;
-  int __pyx_t_1;
-
-  /* "View.MemoryView":300
- * cdef void *align_pointer(void *memory, size_t alignment) nogil:
- *     "Align pointer memory on a given boundary"
- *     cdef Py_intptr_t aligned_p = <Py_intptr_t> memory             # <<<<<<<<<<<<<<
- *     cdef size_t offset
- * 
- */
-  __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory);
-
-  /* "View.MemoryView":304
- * 
- *     with cython.cdivision(True):
- *         offset = aligned_p % alignment             # <<<<<<<<<<<<<<
- * 
- *     if offset > 0:
- */
-  __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment);
-
-  /* "View.MemoryView":306
- *         offset = aligned_p % alignment
- * 
- *     if offset > 0:             # <<<<<<<<<<<<<<
- *         aligned_p += alignment - offset
- * 
- */
-  __pyx_t_1 = ((__pyx_v_offset > 0) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":307
- * 
- *     if offset > 0:
- *         aligned_p += alignment - offset             # <<<<<<<<<<<<<<
- * 
- *     return <void *> aligned_p
- */
-    __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset));
-
-    /* "View.MemoryView":306
- *         offset = aligned_p % alignment
- * 
- *     if offset > 0:             # <<<<<<<<<<<<<<
- *         aligned_p += alignment - offset
- * 
- */
-  }
-
-  /* "View.MemoryView":309
- *         aligned_p += alignment - offset
- * 
- *     return <void *> aligned_p             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_r = ((void *)__pyx_v_aligned_p);
-  goto __pyx_L0;
-
-  /* "View.MemoryView":298
- * 
- * @cname('__pyx_align_pointer')
- * cdef void *align_pointer(void *memory, size_t alignment) nogil:             # <<<<<<<<<<<<<<
- *     "Align pointer memory on a given boundary"
- *     cdef Py_intptr_t aligned_p = <Py_intptr_t> memory
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "View.MemoryView":345
- *     cdef __Pyx_TypeInfo *typeinfo
- * 
- *     def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):             # <<<<<<<<<<<<<<
- *         self.obj = obj
- *         self.flags = flags
- */
-
-/* Python wrapper */
-static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_obj = 0;
-  int __pyx_v_flags;
-  int __pyx_v_dtype_is_object;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0};
-    PyObject* values[3] = {0,0,0};
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 345, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 345, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-    }
-    __pyx_v_obj = values[0];
-    __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 345, __pyx_L3_error)
-    if (values[2]) {
-      __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 345, __pyx_L3_error)
-    } else {
-      __pyx_v_dtype_is_object = ((int)0);
-    }
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 345, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return -1;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object);
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  int __pyx_t_4;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
-
-  /* "View.MemoryView":346
- * 
- *     def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):
- *         self.obj = obj             # <<<<<<<<<<<<<<
- *         self.flags = flags
- *         if type(self) is memoryview or obj is not None:
- */
-  __Pyx_INCREF(__pyx_v_obj);
-  __Pyx_GIVEREF(__pyx_v_obj);
-  __Pyx_GOTREF(__pyx_v_self->obj);
-  __Pyx_DECREF(__pyx_v_self->obj);
-  __pyx_v_self->obj = __pyx_v_obj;
-
-  /* "View.MemoryView":347
- *     def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):
- *         self.obj = obj
- *         self.flags = flags             # <<<<<<<<<<<<<<
- *         if type(self) is memoryview or obj is not None:
- *             __Pyx_GetBuffer(obj, &self.view, flags)
- */
-  __pyx_v_self->flags = __pyx_v_flags;
-
-  /* "View.MemoryView":348
- *         self.obj = obj
- *         self.flags = flags
- *         if type(self) is memoryview or obj is not None:             # <<<<<<<<<<<<<<
- *             __Pyx_GetBuffer(obj, &self.view, flags)
- *             if <PyObject *> self.view.obj == NULL:
- */
-  __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type));
-  __pyx_t_3 = (__pyx_t_2 != 0);
-  if (!__pyx_t_3) {
-  } else {
-    __pyx_t_1 = __pyx_t_3;
-    goto __pyx_L4_bool_binop_done;
-  }
-  __pyx_t_3 = (__pyx_v_obj != Py_None);
-  __pyx_t_2 = (__pyx_t_3 != 0);
-  __pyx_t_1 = __pyx_t_2;
-  __pyx_L4_bool_binop_done:;
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":349
- *         self.flags = flags
- *         if type(self) is memoryview or obj is not None:
- *             __Pyx_GetBuffer(obj, &self.view, flags)             # <<<<<<<<<<<<<<
- *             if <PyObject *> self.view.obj == NULL:
- *                 (<__pyx_buffer *> &self.view).obj = Py_None
- */
-    __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 349, __pyx_L1_error)
-
-    /* "View.MemoryView":350
- *         if type(self) is memoryview or obj is not None:
- *             __Pyx_GetBuffer(obj, &self.view, flags)
- *             if <PyObject *> self.view.obj == NULL:             # <<<<<<<<<<<<<<
- *                 (<__pyx_buffer *> &self.view).obj = Py_None
- *                 Py_INCREF(Py_None)
- */
-    __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0);
-    if (__pyx_t_1) {
-
-      /* "View.MemoryView":351
- *             __Pyx_GetBuffer(obj, &self.view, flags)
- *             if <PyObject *> self.view.obj == NULL:
- *                 (<__pyx_buffer *> &self.view).obj = Py_None             # <<<<<<<<<<<<<<
- *                 Py_INCREF(Py_None)
- * 
- */
-      ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None;
-
-      /* "View.MemoryView":352
- *             if <PyObject *> self.view.obj == NULL:
- *                 (<__pyx_buffer *> &self.view).obj = Py_None
- *                 Py_INCREF(Py_None)             # <<<<<<<<<<<<<<
- * 
- *         global __pyx_memoryview_thread_locks_used
- */
-      Py_INCREF(Py_None);
-
-      /* "View.MemoryView":350
- *         if type(self) is memoryview or obj is not None:
- *             __Pyx_GetBuffer(obj, &self.view, flags)
- *             if <PyObject *> self.view.obj == NULL:             # <<<<<<<<<<<<<<
- *                 (<__pyx_buffer *> &self.view).obj = Py_None
- *                 Py_INCREF(Py_None)
- */
-    }
-
-    /* "View.MemoryView":348
- *         self.obj = obj
- *         self.flags = flags
- *         if type(self) is memoryview or obj is not None:             # <<<<<<<<<<<<<<
- *             __Pyx_GetBuffer(obj, &self.view, flags)
- *             if <PyObject *> self.view.obj == NULL:
- */
-  }
-
-  /* "View.MemoryView":355
- * 
- *         global __pyx_memoryview_thread_locks_used
- *         if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED:             # <<<<<<<<<<<<<<
- *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
- *             __pyx_memoryview_thread_locks_used += 1
- */
-  __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":356
- *         global __pyx_memoryview_thread_locks_used
- *         if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED:
- *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]             # <<<<<<<<<<<<<<
- *             __pyx_memoryview_thread_locks_used += 1
- *         if self.lock is NULL:
- */
-    __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]);
-
-    /* "View.MemoryView":357
- *         if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED:
- *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
- *             __pyx_memoryview_thread_locks_used += 1             # <<<<<<<<<<<<<<
- *         if self.lock is NULL:
- *             self.lock = PyThread_allocate_lock()
- */
-    __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1);
-
-    /* "View.MemoryView":355
- * 
- *         global __pyx_memoryview_thread_locks_used
- *         if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED:             # <<<<<<<<<<<<<<
- *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
- *             __pyx_memoryview_thread_locks_used += 1
- */
-  }
-
-  /* "View.MemoryView":358
- *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
- *             __pyx_memoryview_thread_locks_used += 1
- *         if self.lock is NULL:             # <<<<<<<<<<<<<<
- *             self.lock = PyThread_allocate_lock()
- *             if self.lock is NULL:
- */
-  __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":359
- *             __pyx_memoryview_thread_locks_used += 1
- *         if self.lock is NULL:
- *             self.lock = PyThread_allocate_lock()             # <<<<<<<<<<<<<<
- *             if self.lock is NULL:
- *                 raise MemoryError
- */
-    __pyx_v_self->lock = PyThread_allocate_lock();
-
-    /* "View.MemoryView":360
- *         if self.lock is NULL:
- *             self.lock = PyThread_allocate_lock()
- *             if self.lock is NULL:             # <<<<<<<<<<<<<<
- *                 raise MemoryError
- * 
- */
-    __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0);
-    if (unlikely(__pyx_t_1)) {
-
-      /* "View.MemoryView":361
- *             self.lock = PyThread_allocate_lock()
- *             if self.lock is NULL:
- *                 raise MemoryError             # <<<<<<<<<<<<<<
- * 
- *         if flags & PyBUF_FORMAT:
- */
-      PyErr_NoMemory(); __PYX_ERR(1, 361, __pyx_L1_error)
-
-      /* "View.MemoryView":360
- *         if self.lock is NULL:
- *             self.lock = PyThread_allocate_lock()
- *             if self.lock is NULL:             # <<<<<<<<<<<<<<
- *                 raise MemoryError
- * 
- */
-    }
-
-    /* "View.MemoryView":358
- *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
- *             __pyx_memoryview_thread_locks_used += 1
- *         if self.lock is NULL:             # <<<<<<<<<<<<<<
- *             self.lock = PyThread_allocate_lock()
- *             if self.lock is NULL:
- */
-  }
-
-  /* "View.MemoryView":363
- *                 raise MemoryError
- * 
- *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
- *             self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
- *         else:
- */
-  __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":364
- * 
- *         if flags & PyBUF_FORMAT:
- *             self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')             # <<<<<<<<<<<<<<
- *         else:
- *             self.dtype_is_object = dtype_is_object
- */
-    __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0);
-    if (__pyx_t_2) {
-    } else {
-      __pyx_t_1 = __pyx_t_2;
-      goto __pyx_L11_bool_binop_done;
-    }
-    __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0);
-    __pyx_t_1 = __pyx_t_2;
-    __pyx_L11_bool_binop_done:;
-    __pyx_v_self->dtype_is_object = __pyx_t_1;
-
-    /* "View.MemoryView":363
- *                 raise MemoryError
- * 
- *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
- *             self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
- *         else:
- */
-    goto __pyx_L10;
-  }
-
-  /* "View.MemoryView":366
- *             self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
- *         else:
- *             self.dtype_is_object = dtype_is_object             # <<<<<<<<<<<<<<
- * 
- *         self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer(
- */
-  /*else*/ {
-    __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object;
-  }
-  __pyx_L10:;
-
-  /* "View.MemoryView":368
- *             self.dtype_is_object = dtype_is_object
- * 
- *         self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer(             # <<<<<<<<<<<<<<
- *                   <void *> &self.acquisition_count[0], sizeof(__pyx_atomic_int))
- *         self.typeinfo = NULL
- */
-  __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int))));
-
-  /* "View.MemoryView":370
- *         self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer(
- *                   <void *> &self.acquisition_count[0], sizeof(__pyx_atomic_int))
- *         self.typeinfo = NULL             # <<<<<<<<<<<<<<
- * 
- *     def __dealloc__(memoryview self):
- */
-  __pyx_v_self->typeinfo = NULL;
-
-  /* "View.MemoryView":345
- *     cdef __Pyx_TypeInfo *typeinfo
- * 
- *     def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):             # <<<<<<<<<<<<<<
- *         self.obj = obj
- *         self.flags = flags
- */
-
-  /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":372
- *         self.typeinfo = NULL
- * 
- *     def __dealloc__(memoryview self):             # <<<<<<<<<<<<<<
- *         if self.obj is not None:
- *             __Pyx_ReleaseBuffer(&self.view)
- */
-
-/* Python wrapper */
-static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/
-static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
-  __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  int __pyx_v_i;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  int __pyx_t_4;
-  int __pyx_t_5;
-  PyThread_type_lock __pyx_t_6;
-  PyThread_type_lock __pyx_t_7;
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
-
-  /* "View.MemoryView":373
- * 
- *     def __dealloc__(memoryview self):
- *         if self.obj is not None:             # <<<<<<<<<<<<<<
- *             __Pyx_ReleaseBuffer(&self.view)
- *         elif (<__pyx_buffer *> &self.view).obj == Py_None:
- */
-  __pyx_t_1 = (__pyx_v_self->obj != Py_None);
-  __pyx_t_2 = (__pyx_t_1 != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":374
- *     def __dealloc__(memoryview self):
- *         if self.obj is not None:
- *             __Pyx_ReleaseBuffer(&self.view)             # <<<<<<<<<<<<<<
- *         elif (<__pyx_buffer *> &self.view).obj == Py_None:
- * 
- */
-    __Pyx_ReleaseBuffer((&__pyx_v_self->view));
-
-    /* "View.MemoryView":373
- * 
- *     def __dealloc__(memoryview self):
- *         if self.obj is not None:             # <<<<<<<<<<<<<<
- *             __Pyx_ReleaseBuffer(&self.view)
- *         elif (<__pyx_buffer *> &self.view).obj == Py_None:
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":375
- *         if self.obj is not None:
- *             __Pyx_ReleaseBuffer(&self.view)
- *         elif (<__pyx_buffer *> &self.view).obj == Py_None:             # <<<<<<<<<<<<<<
- * 
- *             (<__pyx_buffer *> &self.view).obj = NULL
- */
-  __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":377
- *         elif (<__pyx_buffer *> &self.view).obj == Py_None:
- * 
- *             (<__pyx_buffer *> &self.view).obj = NULL             # <<<<<<<<<<<<<<
- *             Py_DECREF(Py_None)
- * 
- */
-    ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL;
-
-    /* "View.MemoryView":378
- * 
- *             (<__pyx_buffer *> &self.view).obj = NULL
- *             Py_DECREF(Py_None)             # <<<<<<<<<<<<<<
- * 
- *         cdef int i
- */
-    Py_DECREF(Py_None);
-
-    /* "View.MemoryView":375
- *         if self.obj is not None:
- *             __Pyx_ReleaseBuffer(&self.view)
- *         elif (<__pyx_buffer *> &self.view).obj == Py_None:             # <<<<<<<<<<<<<<
- * 
- *             (<__pyx_buffer *> &self.view).obj = NULL
- */
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":382
- *         cdef int i
- *         global __pyx_memoryview_thread_locks_used
- *         if self.lock != NULL:             # <<<<<<<<<<<<<<
- *             for i in range(__pyx_memoryview_thread_locks_used):
- *                 if __pyx_memoryview_thread_locks[i] is self.lock:
- */
-  __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":383
- *         global __pyx_memoryview_thread_locks_used
- *         if self.lock != NULL:
- *             for i in range(__pyx_memoryview_thread_locks_used):             # <<<<<<<<<<<<<<
- *                 if __pyx_memoryview_thread_locks[i] is self.lock:
- *                     __pyx_memoryview_thread_locks_used -= 1
- */
-    __pyx_t_3 = __pyx_memoryview_thread_locks_used;
-    __pyx_t_4 = __pyx_t_3;
-    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
-      __pyx_v_i = __pyx_t_5;
-
-      /* "View.MemoryView":384
- *         if self.lock != NULL:
- *             for i in range(__pyx_memoryview_thread_locks_used):
- *                 if __pyx_memoryview_thread_locks[i] is self.lock:             # <<<<<<<<<<<<<<
- *                     __pyx_memoryview_thread_locks_used -= 1
- *                     if i != __pyx_memoryview_thread_locks_used:
- */
-      __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0);
-      if (__pyx_t_2) {
-
-        /* "View.MemoryView":385
- *             for i in range(__pyx_memoryview_thread_locks_used):
- *                 if __pyx_memoryview_thread_locks[i] is self.lock:
- *                     __pyx_memoryview_thread_locks_used -= 1             # <<<<<<<<<<<<<<
- *                     if i != __pyx_memoryview_thread_locks_used:
- *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
- */
-        __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1);
-
-        /* "View.MemoryView":386
- *                 if __pyx_memoryview_thread_locks[i] is self.lock:
- *                     __pyx_memoryview_thread_locks_used -= 1
- *                     if i != __pyx_memoryview_thread_locks_used:             # <<<<<<<<<<<<<<
- *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
- *                             __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
- */
-        __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0);
-        if (__pyx_t_2) {
-
-          /* "View.MemoryView":388
- *                     if i != __pyx_memoryview_thread_locks_used:
- *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
- *                             __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])             # <<<<<<<<<<<<<<
- *                     break
- *             else:
- */
-          __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]);
-          __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]);
-
-          /* "View.MemoryView":387
- *                     __pyx_memoryview_thread_locks_used -= 1
- *                     if i != __pyx_memoryview_thread_locks_used:
- *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (             # <<<<<<<<<<<<<<
- *                             __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
- *                     break
- */
-          (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6;
-          (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7;
-
-          /* "View.MemoryView":386
- *                 if __pyx_memoryview_thread_locks[i] is self.lock:
- *                     __pyx_memoryview_thread_locks_used -= 1
- *                     if i != __pyx_memoryview_thread_locks_used:             # <<<<<<<<<<<<<<
- *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
- *                             __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
- */
-        }
-
-        /* "View.MemoryView":389
- *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
- *                             __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
- *                     break             # <<<<<<<<<<<<<<
- *             else:
- *                 PyThread_free_lock(self.lock)
- */
-        goto __pyx_L6_break;
-
-        /* "View.MemoryView":384
- *         if self.lock != NULL:
- *             for i in range(__pyx_memoryview_thread_locks_used):
- *                 if __pyx_memoryview_thread_locks[i] is self.lock:             # <<<<<<<<<<<<<<
- *                     __pyx_memoryview_thread_locks_used -= 1
- *                     if i != __pyx_memoryview_thread_locks_used:
- */
-      }
-    }
-    /*else*/ {
-
-      /* "View.MemoryView":391
- *                     break
- *             else:
- *                 PyThread_free_lock(self.lock)             # <<<<<<<<<<<<<<
- * 
- *     cdef char *get_item_pointer(memoryview self, object index) except NULL:
- */
-      PyThread_free_lock(__pyx_v_self->lock);
-    }
-    __pyx_L6_break:;
-
-    /* "View.MemoryView":382
- *         cdef int i
- *         global __pyx_memoryview_thread_locks_used
- *         if self.lock != NULL:             # <<<<<<<<<<<<<<
- *             for i in range(__pyx_memoryview_thread_locks_used):
- *                 if __pyx_memoryview_thread_locks[i] is self.lock:
- */
-  }
-
-  /* "View.MemoryView":372
- *         self.typeinfo = NULL
- * 
- *     def __dealloc__(memoryview self):             # <<<<<<<<<<<<<<
- *         if self.obj is not None:
- *             __Pyx_ReleaseBuffer(&self.view)
- */
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-/* "View.MemoryView":393
- *                 PyThread_free_lock(self.lock)
- * 
- *     cdef char *get_item_pointer(memoryview self, object index) except NULL:             # <<<<<<<<<<<<<<
- *         cdef Py_ssize_t dim
- *         cdef char *itemp = <char *> self.view.buf
- */
-
-static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) {
-  Py_ssize_t __pyx_v_dim;
-  char *__pyx_v_itemp;
-  PyObject *__pyx_v_idx = NULL;
-  char *__pyx_r;
-  __Pyx_RefNannyDeclarations
-  Py_ssize_t __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  Py_ssize_t __pyx_t_3;
-  PyObject *(*__pyx_t_4)(PyObject *);
-  PyObject *__pyx_t_5 = NULL;
-  Py_ssize_t __pyx_t_6;
-  char *__pyx_t_7;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("get_item_pointer", 0);
-
-  /* "View.MemoryView":395
- *     cdef char *get_item_pointer(memoryview self, object index) except NULL:
- *         cdef Py_ssize_t dim
- *         cdef char *itemp = <char *> self.view.buf             # <<<<<<<<<<<<<<
- * 
- *         for dim, idx in enumerate(index):
- */
-  __pyx_v_itemp = ((char *)__pyx_v_self->view.buf);
-
-  /* "View.MemoryView":397
- *         cdef char *itemp = <char *> self.view.buf
- * 
- *         for dim, idx in enumerate(index):             # <<<<<<<<<<<<<<
- *             itemp = pybuffer_index(&self.view, itemp, idx, dim)
- * 
- */
-  __pyx_t_1 = 0;
-  if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) {
-    __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
-    __pyx_t_4 = NULL;
-  } else {
-    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 397, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 397, __pyx_L1_error)
-  }
-  for (;;) {
-    if (likely(!__pyx_t_4)) {
-      if (likely(PyList_CheckExact(__pyx_t_2))) {
-        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 397, __pyx_L1_error)
-        #else
-        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 397, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        #endif
-      } else {
-        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 397, __pyx_L1_error)
-        #else
-        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 397, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        #endif
-      }
-    } else {
-      __pyx_t_5 = __pyx_t_4(__pyx_t_2);
-      if (unlikely(!__pyx_t_5)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 397, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_5);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5);
-    __pyx_t_5 = 0;
-    __pyx_v_dim = __pyx_t_1;
-    __pyx_t_1 = (__pyx_t_1 + 1);
-
-    /* "View.MemoryView":398
- * 
- *         for dim, idx in enumerate(index):
- *             itemp = pybuffer_index(&self.view, itemp, idx, dim)             # <<<<<<<<<<<<<<
- * 
- *         return itemp
- */
-    __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 398, __pyx_L1_error)
-    __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 398, __pyx_L1_error)
-    __pyx_v_itemp = __pyx_t_7;
-
-    /* "View.MemoryView":397
- *         cdef char *itemp = <char *> self.view.buf
- * 
- *         for dim, idx in enumerate(index):             # <<<<<<<<<<<<<<
- *             itemp = pybuffer_index(&self.view, itemp, idx, dim)
- * 
- */
-  }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  /* "View.MemoryView":400
- *             itemp = pybuffer_index(&self.view, itemp, idx, dim)
- * 
- *         return itemp             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_r = __pyx_v_itemp;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":393
- *                 PyThread_free_lock(self.lock)
- * 
- *     cdef char *get_item_pointer(memoryview self, object index) except NULL:             # <<<<<<<<<<<<<<
- *         cdef Py_ssize_t dim
- *         cdef char *itemp = <char *> self.view.buf
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_idx);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":403
- * 
- * 
- *     def __getitem__(memoryview self, object index):             # <<<<<<<<<<<<<<
- *         if index is Ellipsis:
- *             return self
- */
-
-/* Python wrapper */
-static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/
-static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
-  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) {
-  PyObject *__pyx_v_have_slices = NULL;
-  PyObject *__pyx_v_indices = NULL;
-  char *__pyx_v_itemp;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  char *__pyx_t_6;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__getitem__", 0);
-
-  /* "View.MemoryView":404
- * 
- *     def __getitem__(memoryview self, object index):
- *         if index is Ellipsis:             # <<<<<<<<<<<<<<
- *             return self
- * 
- */
-  __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis);
-  __pyx_t_2 = (__pyx_t_1 != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":405
- *     def __getitem__(memoryview self, object index):
- *         if index is Ellipsis:
- *             return self             # <<<<<<<<<<<<<<
- * 
- *         have_slices, indices = _unellipsify(index, self.view.ndim)
- */
-    __Pyx_XDECREF(__pyx_r);
-    __Pyx_INCREF(((PyObject *)__pyx_v_self));
-    __pyx_r = ((PyObject *)__pyx_v_self);
-    goto __pyx_L0;
-
-    /* "View.MemoryView":404
- * 
- *     def __getitem__(memoryview self, object index):
- *         if index is Ellipsis:             # <<<<<<<<<<<<<<
- *             return self
- * 
- */
-  }
-
-  /* "View.MemoryView":407
- *             return self
- * 
- *         have_slices, indices = _unellipsify(index, self.view.ndim)             # <<<<<<<<<<<<<<
- * 
- *         cdef char *itemp
- */
-  __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 407, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (likely(__pyx_t_3 != Py_None)) {
-    PyObject* sequence = __pyx_t_3;
-    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-    if (unlikely(size != 2)) {
-      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
-      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-      __PYX_ERR(1, 407, __pyx_L1_error)
-    }
-    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); 
-    __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); 
-    __Pyx_INCREF(__pyx_t_4);
-    __Pyx_INCREF(__pyx_t_5);
-    #else
-    __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 407, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 407, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    #endif
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  } else {
-    __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 407, __pyx_L1_error)
-  }
-  __pyx_v_have_slices = __pyx_t_4;
-  __pyx_t_4 = 0;
-  __pyx_v_indices = __pyx_t_5;
-  __pyx_t_5 = 0;
-
-  /* "View.MemoryView":410
- * 
- *         cdef char *itemp
- *         if have_slices:             # <<<<<<<<<<<<<<
- *             return memview_slice(self, indices)
- *         else:
- */
-  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 410, __pyx_L1_error)
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":411
- *         cdef char *itemp
- *         if have_slices:
- *             return memview_slice(self, indices)             # <<<<<<<<<<<<<<
- *         else:
- *             itemp = self.get_item_pointer(indices)
- */
-    __Pyx_XDECREF(__pyx_r);
-    __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 411, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_r = __pyx_t_3;
-    __pyx_t_3 = 0;
-    goto __pyx_L0;
-
-    /* "View.MemoryView":410
- * 
- *         cdef char *itemp
- *         if have_slices:             # <<<<<<<<<<<<<<
- *             return memview_slice(self, indices)
- *         else:
- */
-  }
-
-  /* "View.MemoryView":413
- *             return memview_slice(self, indices)
- *         else:
- *             itemp = self.get_item_pointer(indices)             # <<<<<<<<<<<<<<
- *             return self.convert_item_to_object(itemp)
- * 
- */
-  /*else*/ {
-    __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 413, __pyx_L1_error)
-    __pyx_v_itemp = __pyx_t_6;
-
-    /* "View.MemoryView":414
- *         else:
- *             itemp = self.get_item_pointer(indices)
- *             return self.convert_item_to_object(itemp)             # <<<<<<<<<<<<<<
- * 
- *     def __setitem__(memoryview self, object index, object value):
- */
-    __Pyx_XDECREF(__pyx_r);
-    __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 414, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_r = __pyx_t_3;
-    __pyx_t_3 = 0;
-    goto __pyx_L0;
-  }
-
-  /* "View.MemoryView":403
- * 
- * 
- *     def __getitem__(memoryview self, object index):             # <<<<<<<<<<<<<<
- *         if index is Ellipsis:
- *             return self
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_have_slices);
-  __Pyx_XDECREF(__pyx_v_indices);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":416
- *             return self.convert_item_to_object(itemp)
- * 
- *     def __setitem__(memoryview self, object index, object value):             # <<<<<<<<<<<<<<
- *         if self.view.readonly:
- *             raise TypeError("Cannot assign to read-only memoryview")
- */
-
-/* Python wrapper */
-static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/
-static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
-  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
-  PyObject *__pyx_v_have_slices = NULL;
-  PyObject *__pyx_v_obj = NULL;
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setitem__", 0);
-  __Pyx_INCREF(__pyx_v_index);
-
-  /* "View.MemoryView":417
- * 
- *     def __setitem__(memoryview self, object index, object value):
- *         if self.view.readonly:             # <<<<<<<<<<<<<<
- *             raise TypeError("Cannot assign to read-only memoryview")
- * 
- */
-  __pyx_t_1 = (__pyx_v_self->view.readonly != 0);
-  if (unlikely(__pyx_t_1)) {
-
-    /* "View.MemoryView":418
- *     def __setitem__(memoryview self, object index, object value):
- *         if self.view.readonly:
- *             raise TypeError("Cannot assign to read-only memoryview")             # <<<<<<<<<<<<<<
- * 
- *         have_slices, index = _unellipsify(index, self.view.ndim)
- */
-    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(1, 418, __pyx_L1_error)
-
-    /* "View.MemoryView":417
- * 
- *     def __setitem__(memoryview self, object index, object value):
- *         if self.view.readonly:             # <<<<<<<<<<<<<<
- *             raise TypeError("Cannot assign to read-only memoryview")
- * 
- */
-  }
-
-  /* "View.MemoryView":420
- *             raise TypeError("Cannot assign to read-only memoryview")
- * 
- *         have_slices, index = _unellipsify(index, self.view.ndim)             # <<<<<<<<<<<<<<
- * 
- *         if have_slices:
- */
-  __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (likely(__pyx_t_2 != Py_None)) {
-    PyObject* sequence = __pyx_t_2;
-    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-    if (unlikely(size != 2)) {
-      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
-      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-      __PYX_ERR(1, 420, __pyx_L1_error)
-    }
-    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
-    __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
-    __Pyx_INCREF(__pyx_t_3);
-    __Pyx_INCREF(__pyx_t_4);
-    #else
-    __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 420, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 420, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    #endif
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  } else {
-    __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 420, __pyx_L1_error)
-  }
-  __pyx_v_have_slices = __pyx_t_3;
-  __pyx_t_3 = 0;
-  __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4);
-  __pyx_t_4 = 0;
-
-  /* "View.MemoryView":422
- *         have_slices, index = _unellipsify(index, self.view.ndim)
- * 
- *         if have_slices:             # <<<<<<<<<<<<<<
- *             obj = self.is_slice(value)
- *             if obj:
- */
-  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 422, __pyx_L1_error)
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":423
- * 
- *         if have_slices:
- *             obj = self.is_slice(value)             # <<<<<<<<<<<<<<
- *             if obj:
- *                 self.setitem_slice_assignment(self[index], obj)
- */
-    __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 423, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_v_obj = __pyx_t_2;
-    __pyx_t_2 = 0;
-
-    /* "View.MemoryView":424
- *         if have_slices:
- *             obj = self.is_slice(value)
- *             if obj:             # <<<<<<<<<<<<<<
- *                 self.setitem_slice_assignment(self[index], obj)
- *             else:
- */
-    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 424, __pyx_L1_error)
-    if (__pyx_t_1) {
-
-      /* "View.MemoryView":425
- *             obj = self.is_slice(value)
- *             if obj:
- *                 self.setitem_slice_assignment(self[index], obj)             # <<<<<<<<<<<<<<
- *             else:
- *                 self.setitem_slice_assign_scalar(self[index], value)
- */
-      __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 425, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
-      /* "View.MemoryView":424
- *         if have_slices:
- *             obj = self.is_slice(value)
- *             if obj:             # <<<<<<<<<<<<<<
- *                 self.setitem_slice_assignment(self[index], obj)
- *             else:
- */
-      goto __pyx_L5;
-    }
-
-    /* "View.MemoryView":427
- *                 self.setitem_slice_assignment(self[index], obj)
- *             else:
- *                 self.setitem_slice_assign_scalar(self[index], value)             # <<<<<<<<<<<<<<
- *         else:
- *             self.setitem_indexed(index, value)
- */
-    /*else*/ {
-      __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(1, 427, __pyx_L1_error)
-      __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    }
-    __pyx_L5:;
-
-    /* "View.MemoryView":422
- *         have_slices, index = _unellipsify(index, self.view.ndim)
- * 
- *         if have_slices:             # <<<<<<<<<<<<<<
- *             obj = self.is_slice(value)
- *             if obj:
- */
-    goto __pyx_L4;
-  }
-
-  /* "View.MemoryView":429
- *                 self.setitem_slice_assign_scalar(self[index], value)
- *         else:
- *             self.setitem_indexed(index, value)             # <<<<<<<<<<<<<<
- * 
- *     cdef is_slice(self, obj):
- */
-  /*else*/ {
-    __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 429, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  }
-  __pyx_L4:;
-
-  /* "View.MemoryView":416
- *             return self.convert_item_to_object(itemp)
- * 
- *     def __setitem__(memoryview self, object index, object value):             # <<<<<<<<<<<<<<
- *         if self.view.readonly:
- *             raise TypeError("Cannot assign to read-only memoryview")
- */
-
-  /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_have_slices);
-  __Pyx_XDECREF(__pyx_v_obj);
-  __Pyx_XDECREF(__pyx_v_index);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":431
- *             self.setitem_indexed(index, value)
- * 
- *     cdef is_slice(self, obj):             # <<<<<<<<<<<<<<
- *         if not isinstance(obj, memoryview):
- *             try:
- */
-
-static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  PyObject *__pyx_t_6 = NULL;
-  PyObject *__pyx_t_7 = NULL;
-  PyObject *__pyx_t_8 = NULL;
-  int __pyx_t_9;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("is_slice", 0);
-  __Pyx_INCREF(__pyx_v_obj);
-
-  /* "View.MemoryView":432
- * 
- *     cdef is_slice(self, obj):
- *         if not isinstance(obj, memoryview):             # <<<<<<<<<<<<<<
- *             try:
- *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- */
-  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); 
-  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":433
- *     cdef is_slice(self, obj):
- *         if not isinstance(obj, memoryview):
- *             try:             # <<<<<<<<<<<<<<
- *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- *                                  self.dtype_is_object)
- */
-    {
-      __Pyx_PyThreadState_declare
-      __Pyx_PyThreadState_assign
-      __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
-      __Pyx_XGOTREF(__pyx_t_3);
-      __Pyx_XGOTREF(__pyx_t_4);
-      __Pyx_XGOTREF(__pyx_t_5);
-      /*try:*/ {
-
-        /* "View.MemoryView":434
- *         if not isinstance(obj, memoryview):
- *             try:
- *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,             # <<<<<<<<<<<<<<
- *                                  self.dtype_is_object)
- *             except TypeError:
- */
-        __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 434, __pyx_L4_error)
-        __Pyx_GOTREF(__pyx_t_6);
-
-        /* "View.MemoryView":435
- *             try:
- *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- *                                  self.dtype_is_object)             # <<<<<<<<<<<<<<
- *             except TypeError:
- *                 return None
- */
-        __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 435, __pyx_L4_error)
-        __Pyx_GOTREF(__pyx_t_7);
-
-        /* "View.MemoryView":434
- *         if not isinstance(obj, memoryview):
- *             try:
- *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,             # <<<<<<<<<<<<<<
- *                                  self.dtype_is_object)
- *             except TypeError:
- */
-        __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 434, __pyx_L4_error)
-        __Pyx_GOTREF(__pyx_t_8);
-        __Pyx_INCREF(__pyx_v_obj);
-        __Pyx_GIVEREF(__pyx_v_obj);
-        PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj);
-        __Pyx_GIVEREF(__pyx_t_6);
-        PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6);
-        __Pyx_GIVEREF(__pyx_t_7);
-        PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7);
-        __pyx_t_6 = 0;
-        __pyx_t_7 = 0;
-        __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 434, __pyx_L4_error)
-        __Pyx_GOTREF(__pyx_t_7);
-        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-        __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7);
-        __pyx_t_7 = 0;
-
-        /* "View.MemoryView":433
- *     cdef is_slice(self, obj):
- *         if not isinstance(obj, memoryview):
- *             try:             # <<<<<<<<<<<<<<
- *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- *                                  self.dtype_is_object)
- */
-      }
-      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-      goto __pyx_L9_try_end;
-      __pyx_L4_error:;
-      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-
-      /* "View.MemoryView":436
- *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- *                                  self.dtype_is_object)
- *             except TypeError:             # <<<<<<<<<<<<<<
- *                 return None
- * 
- */
-      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError);
-      if (__pyx_t_9) {
-        __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
-        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 436, __pyx_L6_except_error)
-        __Pyx_GOTREF(__pyx_t_7);
-        __Pyx_GOTREF(__pyx_t_8);
-        __Pyx_GOTREF(__pyx_t_6);
-
-        /* "View.MemoryView":437
- *                                  self.dtype_is_object)
- *             except TypeError:
- *                 return None             # <<<<<<<<<<<<<<
- * 
- *         return obj
- */
-        __Pyx_XDECREF(__pyx_r);
-        __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-        goto __pyx_L7_except_return;
-      }
-      goto __pyx_L6_except_error;
-      __pyx_L6_except_error:;
-
-      /* "View.MemoryView":433
- *     cdef is_slice(self, obj):
- *         if not isinstance(obj, memoryview):
- *             try:             # <<<<<<<<<<<<<<
- *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- *                                  self.dtype_is_object)
- */
-      __Pyx_XGIVEREF(__pyx_t_3);
-      __Pyx_XGIVEREF(__pyx_t_4);
-      __Pyx_XGIVEREF(__pyx_t_5);
-      __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
-      goto __pyx_L1_error;
-      __pyx_L7_except_return:;
-      __Pyx_XGIVEREF(__pyx_t_3);
-      __Pyx_XGIVEREF(__pyx_t_4);
-      __Pyx_XGIVEREF(__pyx_t_5);
-      __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
-      goto __pyx_L0;
-      __pyx_L9_try_end:;
-    }
-
-    /* "View.MemoryView":432
- * 
- *     cdef is_slice(self, obj):
- *         if not isinstance(obj, memoryview):             # <<<<<<<<<<<<<<
- *             try:
- *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- */
-  }
-
-  /* "View.MemoryView":439
- *                 return None
- * 
- *         return obj             # <<<<<<<<<<<<<<
- * 
- *     cdef setitem_slice_assignment(self, dst, src):
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_obj);
-  __pyx_r = __pyx_v_obj;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":431
- *             self.setitem_indexed(index, value)
- * 
- *     cdef is_slice(self, obj):             # <<<<<<<<<<<<<<
- *         if not isinstance(obj, memoryview):
- *             try:
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_obj);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":441
- *         return obj
- * 
- *     cdef setitem_slice_assignment(self, dst, src):             # <<<<<<<<<<<<<<
- *         cdef __Pyx_memviewslice dst_slice
- *         cdef __Pyx_memviewslice src_slice
- */
-
-static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) {
-  __Pyx_memviewslice __pyx_v_dst_slice;
-  __Pyx_memviewslice __pyx_v_src_slice;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_memviewslice *__pyx_t_1;
-  __Pyx_memviewslice *__pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_t_4;
-  int __pyx_t_5;
-  int __pyx_t_6;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("setitem_slice_assignment", 0);
-
-  /* "View.MemoryView":445
- *         cdef __Pyx_memviewslice src_slice
- * 
- *         memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0],             # <<<<<<<<<<<<<<
- *                                  get_slice_from_memview(dst, &dst_slice)[0],
- *                                  src.ndim, dst.ndim, self.dtype_is_object)
- */
-  if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 445, __pyx_L1_error)
-  __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 445, __pyx_L1_error)
-
-  /* "View.MemoryView":446
- * 
- *         memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0],
- *                                  get_slice_from_memview(dst, &dst_slice)[0],             # <<<<<<<<<<<<<<
- *                                  src.ndim, dst.ndim, self.dtype_is_object)
- * 
- */
-  if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 446, __pyx_L1_error)
-  __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 446, __pyx_L1_error)
-
-  /* "View.MemoryView":447
- *         memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0],
- *                                  get_slice_from_memview(dst, &dst_slice)[0],
- *                                  src.ndim, dst.ndim, self.dtype_is_object)             # <<<<<<<<<<<<<<
- * 
- *     cdef setitem_slice_assign_scalar(self, memoryview dst, value):
- */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 447, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 447, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  /* "View.MemoryView":445
- *         cdef __Pyx_memviewslice src_slice
- * 
- *         memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0],             # <<<<<<<<<<<<<<
- *                                  get_slice_from_memview(dst, &dst_slice)[0],
- *                                  src.ndim, dst.ndim, self.dtype_is_object)
- */
-  __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 445, __pyx_L1_error)
-
-  /* "View.MemoryView":441
- *         return obj
- * 
- *     cdef setitem_slice_assignment(self, dst, src):             # <<<<<<<<<<<<<<
- *         cdef __Pyx_memviewslice dst_slice
- *         cdef __Pyx_memviewslice src_slice
- */
-
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":449
- *                                  src.ndim, dst.ndim, self.dtype_is_object)
- * 
- *     cdef setitem_slice_assign_scalar(self, memoryview dst, value):             # <<<<<<<<<<<<<<
- *         cdef int array[128]
- *         cdef void *tmp = NULL
- */
-
-static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) {
-  int __pyx_v_array[0x80];
-  void *__pyx_v_tmp;
-  void *__pyx_v_item;
-  __Pyx_memviewslice *__pyx_v_dst_slice;
-  __Pyx_memviewslice __pyx_v_tmp_slice;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_memviewslice *__pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_t_4;
-  int __pyx_t_5;
-  char const *__pyx_t_6;
-  PyObject *__pyx_t_7 = NULL;
-  PyObject *__pyx_t_8 = NULL;
-  PyObject *__pyx_t_9 = NULL;
-  PyObject *__pyx_t_10 = NULL;
-  PyObject *__pyx_t_11 = NULL;
-  PyObject *__pyx_t_12 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0);
-
-  /* "View.MemoryView":451
- *     cdef setitem_slice_assign_scalar(self, memoryview dst, value):
- *         cdef int array[128]
- *         cdef void *tmp = NULL             # <<<<<<<<<<<<<<
- *         cdef void *item
- * 
- */
-  __pyx_v_tmp = NULL;
-
-  /* "View.MemoryView":456
- *         cdef __Pyx_memviewslice *dst_slice
- *         cdef __Pyx_memviewslice tmp_slice
- *         dst_slice = get_slice_from_memview(dst, &tmp_slice)             # <<<<<<<<<<<<<<
- * 
- *         if <size_t>self.view.itemsize > sizeof(array):
- */
-  __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 456, __pyx_L1_error)
-  __pyx_v_dst_slice = __pyx_t_1;
-
-  /* "View.MemoryView":458
- *         dst_slice = get_slice_from_memview(dst, &tmp_slice)
- * 
- *         if <size_t>self.view.itemsize > sizeof(array):             # <<<<<<<<<<<<<<
- *             tmp = PyMem_Malloc(self.view.itemsize)
- *             if tmp == NULL:
- */
-  __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":459
- * 
- *         if <size_t>self.view.itemsize > sizeof(array):
- *             tmp = PyMem_Malloc(self.view.itemsize)             # <<<<<<<<<<<<<<
- *             if tmp == NULL:
- *                 raise MemoryError
- */
-    __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize);
-
-    /* "View.MemoryView":460
- *         if <size_t>self.view.itemsize > sizeof(array):
- *             tmp = PyMem_Malloc(self.view.itemsize)
- *             if tmp == NULL:             # <<<<<<<<<<<<<<
- *                 raise MemoryError
- *             item = tmp
- */
-    __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0);
-    if (unlikely(__pyx_t_2)) {
-
-      /* "View.MemoryView":461
- *             tmp = PyMem_Malloc(self.view.itemsize)
- *             if tmp == NULL:
- *                 raise MemoryError             # <<<<<<<<<<<<<<
- *             item = tmp
- *         else:
- */
-      PyErr_NoMemory(); __PYX_ERR(1, 461, __pyx_L1_error)
-
-      /* "View.MemoryView":460
- *         if <size_t>self.view.itemsize > sizeof(array):
- *             tmp = PyMem_Malloc(self.view.itemsize)
- *             if tmp == NULL:             # <<<<<<<<<<<<<<
- *                 raise MemoryError
- *             item = tmp
- */
-    }
-
-    /* "View.MemoryView":462
- *             if tmp == NULL:
- *                 raise MemoryError
- *             item = tmp             # <<<<<<<<<<<<<<
- *         else:
- *             item = <void *> array
- */
-    __pyx_v_item = __pyx_v_tmp;
-
-    /* "View.MemoryView":458
- *         dst_slice = get_slice_from_memview(dst, &tmp_slice)
- * 
- *         if <size_t>self.view.itemsize > sizeof(array):             # <<<<<<<<<<<<<<
- *             tmp = PyMem_Malloc(self.view.itemsize)
- *             if tmp == NULL:
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":464
- *             item = tmp
- *         else:
- *             item = <void *> array             # <<<<<<<<<<<<<<
- * 
- *         try:
- */
-  /*else*/ {
-    __pyx_v_item = ((void *)__pyx_v_array);
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":466
- *             item = <void *> array
- * 
- *         try:             # <<<<<<<<<<<<<<
- *             if self.dtype_is_object:
- *                 (<PyObject **> item)[0] = <PyObject *> value
- */
-  /*try:*/ {
-
-    /* "View.MemoryView":467
- * 
- *         try:
- *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
- *                 (<PyObject **> item)[0] = <PyObject *> value
- *             else:
- */
-    __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":468
- *         try:
- *             if self.dtype_is_object:
- *                 (<PyObject **> item)[0] = <PyObject *> value             # <<<<<<<<<<<<<<
- *             else:
- *                 self.assign_item_from_object(<char *> item, value)
- */
-      (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value);
-
-      /* "View.MemoryView":467
- * 
- *         try:
- *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
- *                 (<PyObject **> item)[0] = <PyObject *> value
- *             else:
- */
-      goto __pyx_L8;
-    }
-
-    /* "View.MemoryView":470
- *                 (<PyObject **> item)[0] = <PyObject *> value
- *             else:
- *                 self.assign_item_from_object(<char *> item, value)             # <<<<<<<<<<<<<<
- * 
- * 
- */
-    /*else*/ {
-      __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 470, __pyx_L6_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    }
-    __pyx_L8:;
-
-    /* "View.MemoryView":474
- * 
- * 
- *             if self.view.suboffsets != NULL:             # <<<<<<<<<<<<<<
- *                 assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
- *             slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
- */
-    __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":475
- * 
- *             if self.view.suboffsets != NULL:
- *                 assert_direct_dimensions(self.view.suboffsets, self.view.ndim)             # <<<<<<<<<<<<<<
- *             slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
- *                                 item, self.dtype_is_object)
- */
-      __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 475, __pyx_L6_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-      /* "View.MemoryView":474
- * 
- * 
- *             if self.view.suboffsets != NULL:             # <<<<<<<<<<<<<<
- *                 assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
- *             slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
- */
-    }
-
-    /* "View.MemoryView":476
- *             if self.view.suboffsets != NULL:
- *                 assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
- *             slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,             # <<<<<<<<<<<<<<
- *                                 item, self.dtype_is_object)
- *         finally:
- */
-    __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object);
-  }
-
-  /* "View.MemoryView":479
- *                                 item, self.dtype_is_object)
- *         finally:
- *             PyMem_Free(tmp)             # <<<<<<<<<<<<<<
- * 
- *     cdef setitem_indexed(self, index, value):
- */
-  /*finally:*/ {
-    /*normal exit:*/{
-      PyMem_Free(__pyx_v_tmp);
-      goto __pyx_L7;
-    }
-    __pyx_L6_error:;
-    /*exception exit:*/{
-      __Pyx_PyThreadState_declare
-      __Pyx_PyThreadState_assign
-      __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
-      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
-      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
-      __Pyx_XGOTREF(__pyx_t_7);
-      __Pyx_XGOTREF(__pyx_t_8);
-      __Pyx_XGOTREF(__pyx_t_9);
-      __Pyx_XGOTREF(__pyx_t_10);
-      __Pyx_XGOTREF(__pyx_t_11);
-      __Pyx_XGOTREF(__pyx_t_12);
-      __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
-      {
-        PyMem_Free(__pyx_v_tmp);
-      }
-      if (PY_MAJOR_VERSION >= 3) {
-        __Pyx_XGIVEREF(__pyx_t_10);
-        __Pyx_XGIVEREF(__pyx_t_11);
-        __Pyx_XGIVEREF(__pyx_t_12);
-        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
-      }
-      __Pyx_XGIVEREF(__pyx_t_7);
-      __Pyx_XGIVEREF(__pyx_t_8);
-      __Pyx_XGIVEREF(__pyx_t_9);
-      __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9);
-      __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
-      __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6;
-      goto __pyx_L1_error;
-    }
-    __pyx_L7:;
-  }
-
-  /* "View.MemoryView":449
- *                                  src.ndim, dst.ndim, self.dtype_is_object)
- * 
- *     cdef setitem_slice_assign_scalar(self, memoryview dst, value):             # <<<<<<<<<<<<<<
- *         cdef int array[128]
- *         cdef void *tmp = NULL
- */
-
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":481
- *             PyMem_Free(tmp)
- * 
- *     cdef setitem_indexed(self, index, value):             # <<<<<<<<<<<<<<
- *         cdef char *itemp = self.get_item_pointer(index)
- *         self.assign_item_from_object(itemp, value)
- */
-
-static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
-  char *__pyx_v_itemp;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  char *__pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("setitem_indexed", 0);
-
-  /* "View.MemoryView":482
- * 
- *     cdef setitem_indexed(self, index, value):
- *         cdef char *itemp = self.get_item_pointer(index)             # <<<<<<<<<<<<<<
- *         self.assign_item_from_object(itemp, value)
- * 
- */
-  __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 482, __pyx_L1_error)
-  __pyx_v_itemp = __pyx_t_1;
-
-  /* "View.MemoryView":483
- *     cdef setitem_indexed(self, index, value):
- *         cdef char *itemp = self.get_item_pointer(index)
- *         self.assign_item_from_object(itemp, value)             # <<<<<<<<<<<<<<
- * 
- *     cdef convert_item_to_object(self, char *itemp):
- */
-  __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 483, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  /* "View.MemoryView":481
- *             PyMem_Free(tmp)
- * 
- *     cdef setitem_indexed(self, index, value):             # <<<<<<<<<<<<<<
- *         cdef char *itemp = self.get_item_pointer(index)
- *         self.assign_item_from_object(itemp, value)
- */
-
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":485
- *         self.assign_item_from_object(itemp, value)
- * 
- *     cdef convert_item_to_object(self, char *itemp):             # <<<<<<<<<<<<<<
- *         """Only used if instantiated manually by the user, or if Cython doesn't
- *         know how to convert the type"""
- */
-
-static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) {
-  PyObject *__pyx_v_struct = NULL;
-  PyObject *__pyx_v_bytesitem = 0;
-  PyObject *__pyx_v_result = NULL;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  PyObject *__pyx_t_6 = NULL;
-  PyObject *__pyx_t_7 = NULL;
-  int __pyx_t_8;
-  PyObject *__pyx_t_9 = NULL;
-  size_t __pyx_t_10;
-  int __pyx_t_11;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("convert_item_to_object", 0);
-
-  /* "View.MemoryView":488
- *         """Only used if instantiated manually by the user, or if Cython doesn't
- *         know how to convert the type"""
- *         import struct             # <<<<<<<<<<<<<<
- *         cdef bytes bytesitem
- * 
- */
-  __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 488, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_struct = __pyx_t_1;
-  __pyx_t_1 = 0;
-
-  /* "View.MemoryView":491
- *         cdef bytes bytesitem
- * 
- *         bytesitem = itemp[:self.view.itemsize]             # <<<<<<<<<<<<<<
- *         try:
- *             result = struct.unpack(self.view.format, bytesitem)
- */
-  __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 491, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_bytesitem = ((PyObject*)__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  /* "View.MemoryView":492
- * 
- *         bytesitem = itemp[:self.view.itemsize]
- *         try:             # <<<<<<<<<<<<<<
- *             result = struct.unpack(self.view.format, bytesitem)
- *         except struct.error:
- */
-  {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
-    __Pyx_XGOTREF(__pyx_t_2);
-    __Pyx_XGOTREF(__pyx_t_3);
-    __Pyx_XGOTREF(__pyx_t_4);
-    /*try:*/ {
-
-      /* "View.MemoryView":493
- *         bytesitem = itemp[:self.view.itemsize]
- *         try:
- *             result = struct.unpack(self.view.format, bytesitem)             # <<<<<<<<<<<<<<
- *         except struct.error:
- *             raise ValueError("Unable to convert item to object")
- */
-      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 493, __pyx_L3_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 493, __pyx_L3_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __pyx_t_7 = NULL;
-      __pyx_t_8 = 0;
-      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
-        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
-        if (likely(__pyx_t_7)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-          __Pyx_INCREF(__pyx_t_7);
-          __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_5, function);
-          __pyx_t_8 = 1;
-        }
-      }
-      #if CYTHON_FAST_PYCALL
-      if (PyFunction_Check(__pyx_t_5)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem};
-        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L3_error)
-        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-        __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      } else
-      #endif
-      #if CYTHON_FAST_PYCCALL
-      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem};
-        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L3_error)
-        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-        __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      } else
-      #endif
-      {
-        __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 493, __pyx_L3_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        if (__pyx_t_7) {
-          __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
-        }
-        __Pyx_GIVEREF(__pyx_t_6);
-        PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6);
-        __Pyx_INCREF(__pyx_v_bytesitem);
-        __Pyx_GIVEREF(__pyx_v_bytesitem);
-        PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem);
-        __pyx_t_6 = 0;
-        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L3_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      }
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_v_result = __pyx_t_1;
-      __pyx_t_1 = 0;
-
-      /* "View.MemoryView":492
- * 
- *         bytesitem = itemp[:self.view.itemsize]
- *         try:             # <<<<<<<<<<<<<<
- *             result = struct.unpack(self.view.format, bytesitem)
- *         except struct.error:
- */
-    }
-
-    /* "View.MemoryView":497
- *             raise ValueError("Unable to convert item to object")
- *         else:
- *             if len(self.view.format) == 1:             # <<<<<<<<<<<<<<
- *                 return result[0]
- *             return result
- */
-    /*else:*/ {
-      __pyx_t_10 = strlen(__pyx_v_self->view.format); 
-      __pyx_t_11 = ((__pyx_t_10 == 1) != 0);
-      if (__pyx_t_11) {
-
-        /* "View.MemoryView":498
- *         else:
- *             if len(self.view.format) == 1:
- *                 return result[0]             # <<<<<<<<<<<<<<
- *             return result
- * 
- */
-        __Pyx_XDECREF(__pyx_r);
-        __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 498, __pyx_L5_except_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        __pyx_r = __pyx_t_1;
-        __pyx_t_1 = 0;
-        goto __pyx_L6_except_return;
-
-        /* "View.MemoryView":497
- *             raise ValueError("Unable to convert item to object")
- *         else:
- *             if len(self.view.format) == 1:             # <<<<<<<<<<<<<<
- *                 return result[0]
- *             return result
- */
-      }
-
-      /* "View.MemoryView":499
- *             if len(self.view.format) == 1:
- *                 return result[0]
- *             return result             # <<<<<<<<<<<<<<
- * 
- *     cdef assign_item_from_object(self, char *itemp, object value):
- */
-      __Pyx_XDECREF(__pyx_r);
-      __Pyx_INCREF(__pyx_v_result);
-      __pyx_r = __pyx_v_result;
-      goto __pyx_L6_except_return;
-    }
-    __pyx_L3_error:;
-    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-
-    /* "View.MemoryView":494
- *         try:
- *             result = struct.unpack(self.view.format, bytesitem)
- *         except struct.error:             # <<<<<<<<<<<<<<
- *             raise ValueError("Unable to convert item to object")
- *         else:
- */
-    __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9);
-    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 494, __pyx_L5_except_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6);
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9);
-    __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0;
-    if (__pyx_t_8) {
-      __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 494, __pyx_L5_except_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_GOTREF(__pyx_t_1);
-
-      /* "View.MemoryView":495
- *             result = struct.unpack(self.view.format, bytesitem)
- *         except struct.error:
- *             raise ValueError("Unable to convert item to object")             # <<<<<<<<<<<<<<
- *         else:
- *             if len(self.view.format) == 1:
- */
-      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 495, __pyx_L5_except_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      __PYX_ERR(1, 495, __pyx_L5_except_error)
-    }
-    goto __pyx_L5_except_error;
-    __pyx_L5_except_error:;
-
-    /* "View.MemoryView":492
- * 
- *         bytesitem = itemp[:self.view.itemsize]
- *         try:             # <<<<<<<<<<<<<<
- *             result = struct.unpack(self.view.format, bytesitem)
- *         except struct.error:
- */
-    __Pyx_XGIVEREF(__pyx_t_2);
-    __Pyx_XGIVEREF(__pyx_t_3);
-    __Pyx_XGIVEREF(__pyx_t_4);
-    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
-    goto __pyx_L1_error;
-    __pyx_L6_except_return:;
-    __Pyx_XGIVEREF(__pyx_t_2);
-    __Pyx_XGIVEREF(__pyx_t_3);
-    __Pyx_XGIVEREF(__pyx_t_4);
-    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
-    goto __pyx_L0;
-  }
-
-  /* "View.MemoryView":485
- *         self.assign_item_from_object(itemp, value)
- * 
- *     cdef convert_item_to_object(self, char *itemp):             # <<<<<<<<<<<<<<
- *         """Only used if instantiated manually by the user, or if Cython doesn't
- *         know how to convert the type"""
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_struct);
-  __Pyx_XDECREF(__pyx_v_bytesitem);
-  __Pyx_XDECREF(__pyx_v_result);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":501
- *             return result
- * 
- *     cdef assign_item_from_object(self, char *itemp, object value):             # <<<<<<<<<<<<<<
- *         """Only used if instantiated manually by the user, or if Cython doesn't
- *         know how to convert the type"""
- */
-
-static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) {
-  PyObject *__pyx_v_struct = NULL;
-  char __pyx_v_c;
-  PyObject *__pyx_v_bytesvalue = 0;
-  Py_ssize_t __pyx_v_i;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  PyObject *__pyx_t_6 = NULL;
-  int __pyx_t_7;
-  PyObject *__pyx_t_8 = NULL;
-  Py_ssize_t __pyx_t_9;
-  PyObject *__pyx_t_10 = NULL;
-  char *__pyx_t_11;
-  char *__pyx_t_12;
-  char *__pyx_t_13;
-  char *__pyx_t_14;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("assign_item_from_object", 0);
-
-  /* "View.MemoryView":504
- *         """Only used if instantiated manually by the user, or if Cython doesn't
- *         know how to convert the type"""
- *         import struct             # <<<<<<<<<<<<<<
- *         cdef char c
- *         cdef bytes bytesvalue
- */
-  __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 504, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_struct = __pyx_t_1;
-  __pyx_t_1 = 0;
-
-  /* "View.MemoryView":509
- *         cdef Py_ssize_t i
- * 
- *         if isinstance(value, tuple):             # <<<<<<<<<<<<<<
- *             bytesvalue = struct.pack(self.view.format, *value)
- *         else:
- */
-  __pyx_t_2 = PyTuple_Check(__pyx_v_value); 
-  __pyx_t_3 = (__pyx_t_2 != 0);
-  if (__pyx_t_3) {
-
-    /* "View.MemoryView":510
- * 
- *         if isinstance(value, tuple):
- *             bytesvalue = struct.pack(self.view.format, *value)             # <<<<<<<<<<<<<<
- *         else:
- *             bytesvalue = struct.pack(self.view.format, value)
- */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 510, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 510, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 510, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __Pyx_GIVEREF(__pyx_t_4);
-    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
-    __pyx_t_4 = 0;
-    __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 510, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 510, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 510, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 510, __pyx_L1_error)
-    __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4);
-    __pyx_t_4 = 0;
-
-    /* "View.MemoryView":509
- *         cdef Py_ssize_t i
- * 
- *         if isinstance(value, tuple):             # <<<<<<<<<<<<<<
- *             bytesvalue = struct.pack(self.view.format, *value)
- *         else:
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":512
- *             bytesvalue = struct.pack(self.view.format, *value)
- *         else:
- *             bytesvalue = struct.pack(self.view.format, value)             # <<<<<<<<<<<<<<
- * 
- *         for i, c in enumerate(bytesvalue):
- */
-  /*else*/ {
-    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 512, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 512, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_5 = NULL;
-    __pyx_t_7 = 0;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
-      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
-      if (likely(__pyx_t_5)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
-        __Pyx_INCREF(__pyx_t_5);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_6, function);
-        __pyx_t_7 = 1;
-      }
-    }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_6)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value};
-      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    } else
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value};
-      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    } else
-    #endif
-    {
-      __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 512, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      if (__pyx_t_5) {
-        __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
-      }
-      __Pyx_GIVEREF(__pyx_t_1);
-      PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1);
-      __Pyx_INCREF(__pyx_v_value);
-      __Pyx_GIVEREF(__pyx_v_value);
-      PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value);
-      __pyx_t_1 = 0;
-      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    }
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 512, __pyx_L1_error)
-    __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4);
-    __pyx_t_4 = 0;
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":514
- *             bytesvalue = struct.pack(self.view.format, value)
- * 
- *         for i, c in enumerate(bytesvalue):             # <<<<<<<<<<<<<<
- *             itemp[i] = c
- * 
- */
-  __pyx_t_9 = 0;
-  if (unlikely(__pyx_v_bytesvalue == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable");
-    __PYX_ERR(1, 514, __pyx_L1_error)
-  }
-  __Pyx_INCREF(__pyx_v_bytesvalue);
-  __pyx_t_10 = __pyx_v_bytesvalue;
-  __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10);
-  __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10));
-  for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) {
-    __pyx_t_11 = __pyx_t_14;
-    __pyx_v_c = (__pyx_t_11[0]);
-
-    /* "View.MemoryView":515
- * 
- *         for i, c in enumerate(bytesvalue):
- *             itemp[i] = c             # <<<<<<<<<<<<<<
- * 
- *     @cname('getbuffer')
- */
-    __pyx_v_i = __pyx_t_9;
-
-    /* "View.MemoryView":514
- *             bytesvalue = struct.pack(self.view.format, value)
- * 
- *         for i, c in enumerate(bytesvalue):             # <<<<<<<<<<<<<<
- *             itemp[i] = c
- * 
- */
-    __pyx_t_9 = (__pyx_t_9 + 1);
-
-    /* "View.MemoryView":515
- * 
- *         for i, c in enumerate(bytesvalue):
- *             itemp[i] = c             # <<<<<<<<<<<<<<
- * 
- *     @cname('getbuffer')
- */
-    (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c;
-  }
-  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-
-  /* "View.MemoryView":501
- *             return result
- * 
- *     cdef assign_item_from_object(self, char *itemp, object value):             # <<<<<<<<<<<<<<
- *         """Only used if instantiated manually by the user, or if Cython doesn't
- *         know how to convert the type"""
- */
-
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_XDECREF(__pyx_t_10);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_struct);
-  __Pyx_XDECREF(__pyx_v_bytesvalue);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":518
- * 
- *     @cname('getbuffer')
- *     def __getbuffer__(self, Py_buffer *info, int flags):             # <<<<<<<<<<<<<<
- *         if flags & PyBUF_WRITABLE and self.view.readonly:
- *             raise ValueError("Cannot create writable memory view from read-only memoryview")
- */
-
-/* Python wrapper */
-static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
-static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
-  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  Py_ssize_t *__pyx_t_4;
-  char *__pyx_t_5;
-  void *__pyx_t_6;
-  int __pyx_t_7;
-  Py_ssize_t __pyx_t_8;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  if (__pyx_v_info == NULL) {
-    PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
-    return -1;
-  }
-  __Pyx_RefNannySetupContext("__getbuffer__", 0);
-  __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
-  __Pyx_GIVEREF(__pyx_v_info->obj);
-
-  /* "View.MemoryView":519
- *     @cname('getbuffer')
- *     def __getbuffer__(self, Py_buffer *info, int flags):
- *         if flags & PyBUF_WRITABLE and self.view.readonly:             # <<<<<<<<<<<<<<
- *             raise ValueError("Cannot create writable memory view from read-only memoryview")
- * 
- */
-  __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0);
-  if (__pyx_t_2) {
-  } else {
-    __pyx_t_1 = __pyx_t_2;
-    goto __pyx_L4_bool_binop_done;
-  }
-  __pyx_t_2 = (__pyx_v_self->view.readonly != 0);
-  __pyx_t_1 = __pyx_t_2;
-  __pyx_L4_bool_binop_done:;
-  if (unlikely(__pyx_t_1)) {
-
-    /* "View.MemoryView":520
- *     def __getbuffer__(self, Py_buffer *info, int flags):
- *         if flags & PyBUF_WRITABLE and self.view.readonly:
- *             raise ValueError("Cannot create writable memory view from read-only memoryview")             # <<<<<<<<<<<<<<
- * 
- *         if flags & PyBUF_ND:
- */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 520, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(1, 520, __pyx_L1_error)
-
-    /* "View.MemoryView":519
- *     @cname('getbuffer')
- *     def __getbuffer__(self, Py_buffer *info, int flags):
- *         if flags & PyBUF_WRITABLE and self.view.readonly:             # <<<<<<<<<<<<<<
- *             raise ValueError("Cannot create writable memory view from read-only memoryview")
- * 
- */
-  }
-
-  /* "View.MemoryView":522
- *             raise ValueError("Cannot create writable memory view from read-only memoryview")
- * 
- *         if flags & PyBUF_ND:             # <<<<<<<<<<<<<<
- *             info.shape = self.view.shape
- *         else:
- */
-  __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":523
- * 
- *         if flags & PyBUF_ND:
- *             info.shape = self.view.shape             # <<<<<<<<<<<<<<
- *         else:
- *             info.shape = NULL
- */
-    __pyx_t_4 = __pyx_v_self->view.shape;
-    __pyx_v_info->shape = __pyx_t_4;
-
-    /* "View.MemoryView":522
- *             raise ValueError("Cannot create writable memory view from read-only memoryview")
- * 
- *         if flags & PyBUF_ND:             # <<<<<<<<<<<<<<
- *             info.shape = self.view.shape
- *         else:
- */
-    goto __pyx_L6;
-  }
-
-  /* "View.MemoryView":525
- *             info.shape = self.view.shape
- *         else:
- *             info.shape = NULL             # <<<<<<<<<<<<<<
- * 
- *         if flags & PyBUF_STRIDES:
- */
-  /*else*/ {
-    __pyx_v_info->shape = NULL;
-  }
-  __pyx_L6:;
-
-  /* "View.MemoryView":527
- *             info.shape = NULL
- * 
- *         if flags & PyBUF_STRIDES:             # <<<<<<<<<<<<<<
- *             info.strides = self.view.strides
- *         else:
- */
-  __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":528
- * 
- *         if flags & PyBUF_STRIDES:
- *             info.strides = self.view.strides             # <<<<<<<<<<<<<<
- *         else:
- *             info.strides = NULL
- */
-    __pyx_t_4 = __pyx_v_self->view.strides;
-    __pyx_v_info->strides = __pyx_t_4;
-
-    /* "View.MemoryView":527
- *             info.shape = NULL
- * 
- *         if flags & PyBUF_STRIDES:             # <<<<<<<<<<<<<<
- *             info.strides = self.view.strides
- *         else:
- */
-    goto __pyx_L7;
-  }
-
-  /* "View.MemoryView":530
- *             info.strides = self.view.strides
- *         else:
- *             info.strides = NULL             # <<<<<<<<<<<<<<
- * 
- *         if flags & PyBUF_INDIRECT:
- */
-  /*else*/ {
-    __pyx_v_info->strides = NULL;
-  }
-  __pyx_L7:;
-
-  /* "View.MemoryView":532
- *             info.strides = NULL
- * 
- *         if flags & PyBUF_INDIRECT:             # <<<<<<<<<<<<<<
- *             info.suboffsets = self.view.suboffsets
- *         else:
- */
-  __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":533
- * 
- *         if flags & PyBUF_INDIRECT:
- *             info.suboffsets = self.view.suboffsets             # <<<<<<<<<<<<<<
- *         else:
- *             info.suboffsets = NULL
- */
-    __pyx_t_4 = __pyx_v_self->view.suboffsets;
-    __pyx_v_info->suboffsets = __pyx_t_4;
-
-    /* "View.MemoryView":532
- *             info.strides = NULL
- * 
- *         if flags & PyBUF_INDIRECT:             # <<<<<<<<<<<<<<
- *             info.suboffsets = self.view.suboffsets
- *         else:
- */
-    goto __pyx_L8;
-  }
-
-  /* "View.MemoryView":535
- *             info.suboffsets = self.view.suboffsets
- *         else:
- *             info.suboffsets = NULL             # <<<<<<<<<<<<<<
- * 
- *         if flags & PyBUF_FORMAT:
- */
-  /*else*/ {
-    __pyx_v_info->suboffsets = NULL;
-  }
-  __pyx_L8:;
-
-  /* "View.MemoryView":537
- *             info.suboffsets = NULL
- * 
- *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
- *             info.format = self.view.format
- *         else:
- */
-  __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":538
- * 
- *         if flags & PyBUF_FORMAT:
- *             info.format = self.view.format             # <<<<<<<<<<<<<<
- *         else:
- *             info.format = NULL
- */
-    __pyx_t_5 = __pyx_v_self->view.format;
-    __pyx_v_info->format = __pyx_t_5;
-
-    /* "View.MemoryView":537
- *             info.suboffsets = NULL
- * 
- *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
- *             info.format = self.view.format
- *         else:
- */
-    goto __pyx_L9;
-  }
-
-  /* "View.MemoryView":540
- *             info.format = self.view.format
- *         else:
- *             info.format = NULL             # <<<<<<<<<<<<<<
- * 
- *         info.buf = self.view.buf
- */
-  /*else*/ {
-    __pyx_v_info->format = NULL;
-  }
-  __pyx_L9:;
-
-  /* "View.MemoryView":542
- *             info.format = NULL
- * 
- *         info.buf = self.view.buf             # <<<<<<<<<<<<<<
- *         info.ndim = self.view.ndim
- *         info.itemsize = self.view.itemsize
- */
-  __pyx_t_6 = __pyx_v_self->view.buf;
-  __pyx_v_info->buf = __pyx_t_6;
-
-  /* "View.MemoryView":543
- * 
- *         info.buf = self.view.buf
- *         info.ndim = self.view.ndim             # <<<<<<<<<<<<<<
- *         info.itemsize = self.view.itemsize
- *         info.len = self.view.len
- */
-  __pyx_t_7 = __pyx_v_self->view.ndim;
-  __pyx_v_info->ndim = __pyx_t_7;
-
-  /* "View.MemoryView":544
- *         info.buf = self.view.buf
- *         info.ndim = self.view.ndim
- *         info.itemsize = self.view.itemsize             # <<<<<<<<<<<<<<
- *         info.len = self.view.len
- *         info.readonly = self.view.readonly
- */
-  __pyx_t_8 = __pyx_v_self->view.itemsize;
-  __pyx_v_info->itemsize = __pyx_t_8;
-
-  /* "View.MemoryView":545
- *         info.ndim = self.view.ndim
- *         info.itemsize = self.view.itemsize
- *         info.len = self.view.len             # <<<<<<<<<<<<<<
- *         info.readonly = self.view.readonly
- *         info.obj = self
- */
-  __pyx_t_8 = __pyx_v_self->view.len;
-  __pyx_v_info->len = __pyx_t_8;
-
-  /* "View.MemoryView":546
- *         info.itemsize = self.view.itemsize
- *         info.len = self.view.len
- *         info.readonly = self.view.readonly             # <<<<<<<<<<<<<<
- *         info.obj = self
- * 
- */
-  __pyx_t_1 = __pyx_v_self->view.readonly;
-  __pyx_v_info->readonly = __pyx_t_1;
-
-  /* "View.MemoryView":547
- *         info.len = self.view.len
- *         info.readonly = self.view.readonly
- *         info.obj = self             # <<<<<<<<<<<<<<
- * 
- *     __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")
- */
-  __Pyx_INCREF(((PyObject *)__pyx_v_self));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
-  __Pyx_GOTREF(__pyx_v_info->obj);
-  __Pyx_DECREF(__pyx_v_info->obj);
-  __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
-
-  /* "View.MemoryView":518
- * 
- *     @cname('getbuffer')
- *     def __getbuffer__(self, Py_buffer *info, int flags):             # <<<<<<<<<<<<<<
- *         if flags & PyBUF_WRITABLE and self.view.readonly:
- *             raise ValueError("Cannot create writable memory view from read-only memoryview")
- */
-
-  /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  if (__pyx_v_info->obj != NULL) {
-    __Pyx_GOTREF(__pyx_v_info->obj);
-    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
-  }
-  goto __pyx_L2;
-  __pyx_L0:;
-  if (__pyx_v_info->obj == Py_None) {
-    __Pyx_GOTREF(__pyx_v_info->obj);
-    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
-  }
-  __pyx_L2:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":553
- * 
- *     @property
- *     def T(self):             # <<<<<<<<<<<<<<
- *         cdef _memoryviewslice result = memoryview_copy(self)
- *         transpose_memslice(&result.from_slice)
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  struct __pyx_memoryviewslice_obj *__pyx_v_result = 0;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_t_2;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "View.MemoryView":554
- *     @property
- *     def T(self):
- *         cdef _memoryviewslice result = memoryview_copy(self)             # <<<<<<<<<<<<<<
- *         transpose_memslice(&result.from_slice)
- *         return result
- */
-  __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 554, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(1, 554, __pyx_L1_error)
-  __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  /* "View.MemoryView":555
- *     def T(self):
- *         cdef _memoryviewslice result = memoryview_copy(self)
- *         transpose_memslice(&result.from_slice)             # <<<<<<<<<<<<<<
- *         return result
- * 
- */
-  __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 555, __pyx_L1_error)
-
-  /* "View.MemoryView":556
- *         cdef _memoryviewslice result = memoryview_copy(self)
- *         transpose_memslice(&result.from_slice)
- *         return result             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_result));
-  __pyx_r = ((PyObject *)__pyx_v_result);
-  goto __pyx_L0;
-
-  /* "View.MemoryView":553
- * 
- *     @property
- *     def T(self):             # <<<<<<<<<<<<<<
- *         cdef _memoryviewslice result = memoryview_copy(self)
- *         transpose_memslice(&result.from_slice)
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_result);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":559
- * 
- *     @property
- *     def base(self):             # <<<<<<<<<<<<<<
- *         return self.obj
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "View.MemoryView":560
- *     @property
- *     def base(self):
- *         return self.obj             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_self->obj);
-  __pyx_r = __pyx_v_self->obj;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":559
- * 
- *     @property
- *     def base(self):             # <<<<<<<<<<<<<<
- *         return self.obj
- * 
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":563
- * 
- *     @property
- *     def shape(self):             # <<<<<<<<<<<<<<
- *         return tuple([length for length in self.view.shape[:self.view.ndim]])
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  Py_ssize_t __pyx_v_length;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  Py_ssize_t *__pyx_t_2;
-  Py_ssize_t *__pyx_t_3;
-  Py_ssize_t *__pyx_t_4;
-  PyObject *__pyx_t_5 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "View.MemoryView":564
- *     @property
- *     def shape(self):
- *         return tuple([length for length in self.view.shape[:self.view.ndim]])             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 564, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim);
-  for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) {
-    __pyx_t_2 = __pyx_t_4;
-    __pyx_v_length = (__pyx_t_2[0]);
-    __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 564, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 564, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  }
-  __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 564, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_5;
-  __pyx_t_5 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":563
- * 
- *     @property
- *     def shape(self):             # <<<<<<<<<<<<<<
- *         return tuple([length for length in self.view.shape[:self.view.ndim]])
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":567
- * 
- *     @property
- *     def strides(self):             # <<<<<<<<<<<<<<
- *         if self.view.strides == NULL:
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  Py_ssize_t __pyx_v_stride;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  Py_ssize_t *__pyx_t_3;
-  Py_ssize_t *__pyx_t_4;
-  Py_ssize_t *__pyx_t_5;
-  PyObject *__pyx_t_6 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "View.MemoryView":568
- *     @property
- *     def strides(self):
- *         if self.view.strides == NULL:             # <<<<<<<<<<<<<<
- * 
- *             raise ValueError("Buffer view does not expose strides")
- */
-  __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0);
-  if (unlikely(__pyx_t_1)) {
-
-    /* "View.MemoryView":570
- *         if self.view.strides == NULL:
- * 
- *             raise ValueError("Buffer view does not expose strides")             # <<<<<<<<<<<<<<
- * 
- *         return tuple([stride for stride in self.view.strides[:self.view.ndim]])
- */
-    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 570, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(1, 570, __pyx_L1_error)
-
-    /* "View.MemoryView":568
- *     @property
- *     def strides(self):
- *         if self.view.strides == NULL:             # <<<<<<<<<<<<<<
- * 
- *             raise ValueError("Buffer view does not expose strides")
- */
-  }
-
-  /* "View.MemoryView":572
- *             raise ValueError("Buffer view does not expose strides")
- * 
- *         return tuple([stride for stride in self.view.strides[:self.view.ndim]])             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim);
-  for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) {
-    __pyx_t_3 = __pyx_t_5;
-    __pyx_v_stride = (__pyx_t_3[0]);
-    __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 572, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 572, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-  }
-  __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 572, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_6;
-  __pyx_t_6 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":567
- * 
- *     @property
- *     def strides(self):             # <<<<<<<<<<<<<<
- *         if self.view.strides == NULL:
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":575
- * 
- *     @property
- *     def suboffsets(self):             # <<<<<<<<<<<<<<
- *         if self.view.suboffsets == NULL:
- *             return (-1,) * self.view.ndim
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  Py_ssize_t __pyx_v_suboffset;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  Py_ssize_t *__pyx_t_4;
-  Py_ssize_t *__pyx_t_5;
-  Py_ssize_t *__pyx_t_6;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "View.MemoryView":576
- *     @property
- *     def suboffsets(self):
- *         if self.view.suboffsets == NULL:             # <<<<<<<<<<<<<<
- *             return (-1,) * self.view.ndim
- * 
- */
-  __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":577
- *     def suboffsets(self):
- *         if self.view.suboffsets == NULL:
- *             return (-1,) * self.view.ndim             # <<<<<<<<<<<<<<
- * 
- *         return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
- */
-    __Pyx_XDECREF(__pyx_r);
-    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 577, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __pyx_r = __pyx_t_3;
-    __pyx_t_3 = 0;
-    goto __pyx_L0;
-
-    /* "View.MemoryView":576
- *     @property
- *     def suboffsets(self):
- *         if self.view.suboffsets == NULL:             # <<<<<<<<<<<<<<
- *             return (-1,) * self.view.ndim
- * 
- */
-  }
-
-  /* "View.MemoryView":579
- *             return (-1,) * self.view.ndim
- * 
- *         return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim);
-  for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) {
-    __pyx_t_4 = __pyx_t_6;
-    __pyx_v_suboffset = (__pyx_t_4[0]);
-    __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 579, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  }
-  __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":575
- * 
- *     @property
- *     def suboffsets(self):             # <<<<<<<<<<<<<<
- *         if self.view.suboffsets == NULL:
- *             return (-1,) * self.view.ndim
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":582
- * 
- *     @property
- *     def ndim(self):             # <<<<<<<<<<<<<<
- *         return self.view.ndim
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "View.MemoryView":583
- *     @property
- *     def ndim(self):
- *         return self.view.ndim             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 583, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":582
- * 
- *     @property
- *     def ndim(self):             # <<<<<<<<<<<<<<
- *         return self.view.ndim
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":586
- * 
- *     @property
- *     def itemsize(self):             # <<<<<<<<<<<<<<
- *         return self.view.itemsize
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "View.MemoryView":587
- *     @property
- *     def itemsize(self):
- *         return self.view.itemsize             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 587, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":586
- * 
- *     @property
- *     def itemsize(self):             # <<<<<<<<<<<<<<
- *         return self.view.itemsize
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":590
- * 
- *     @property
- *     def nbytes(self):             # <<<<<<<<<<<<<<
- *         return self.size * self.view.itemsize
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "View.MemoryView":591
- *     @property
- *     def nbytes(self):
- *         return self.size * self.view.itemsize             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 591, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 591, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 591, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_3;
-  __pyx_t_3 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":590
- * 
- *     @property
- *     def nbytes(self):             # <<<<<<<<<<<<<<
- *         return self.size * self.view.itemsize
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":594
- * 
- *     @property
- *     def size(self):             # <<<<<<<<<<<<<<
- *         if self._size is None:
- *             result = 1
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  PyObject *__pyx_v_result = NULL;
-  PyObject *__pyx_v_length = NULL;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  Py_ssize_t *__pyx_t_3;
-  Py_ssize_t *__pyx_t_4;
-  Py_ssize_t *__pyx_t_5;
-  PyObject *__pyx_t_6 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "View.MemoryView":595
- *     @property
- *     def size(self):
- *         if self._size is None:             # <<<<<<<<<<<<<<
- *             result = 1
- * 
- */
-  __pyx_t_1 = (__pyx_v_self->_size == Py_None);
-  __pyx_t_2 = (__pyx_t_1 != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":596
- *     def size(self):
- *         if self._size is None:
- *             result = 1             # <<<<<<<<<<<<<<
- * 
- *             for length in self.view.shape[:self.view.ndim]:
- */
-    __Pyx_INCREF(__pyx_int_1);
-    __pyx_v_result = __pyx_int_1;
-
-    /* "View.MemoryView":598
- *             result = 1
- * 
- *             for length in self.view.shape[:self.view.ndim]:             # <<<<<<<<<<<<<<
- *                 result *= length
- * 
- */
-    __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim);
-    for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) {
-      __pyx_t_3 = __pyx_t_5;
-      __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 598, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6);
-      __pyx_t_6 = 0;
-
-      /* "View.MemoryView":599
- * 
- *             for length in self.view.shape[:self.view.ndim]:
- *                 result *= length             # <<<<<<<<<<<<<<
- * 
- *             self._size = result
- */
-      __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 599, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6);
-      __pyx_t_6 = 0;
-    }
-
-    /* "View.MemoryView":601
- *                 result *= length
- * 
- *             self._size = result             # <<<<<<<<<<<<<<
- * 
- *         return self._size
- */
-    __Pyx_INCREF(__pyx_v_result);
-    __Pyx_GIVEREF(__pyx_v_result);
-    __Pyx_GOTREF(__pyx_v_self->_size);
-    __Pyx_DECREF(__pyx_v_self->_size);
-    __pyx_v_self->_size = __pyx_v_result;
-
-    /* "View.MemoryView":595
- *     @property
- *     def size(self):
- *         if self._size is None:             # <<<<<<<<<<<<<<
- *             result = 1
- * 
- */
-  }
-
-  /* "View.MemoryView":603
- *             self._size = result
- * 
- *         return self._size             # <<<<<<<<<<<<<<
- * 
- *     def __len__(self):
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_self->_size);
-  __pyx_r = __pyx_v_self->_size;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":594
- * 
- *     @property
- *     def size(self):             # <<<<<<<<<<<<<<
- *         if self._size is None:
- *             result = 1
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_result);
-  __Pyx_XDECREF(__pyx_v_length);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":605
- *         return self._size
- * 
- *     def __len__(self):             # <<<<<<<<<<<<<<
- *         if self.view.ndim >= 1:
- *             return self.view.shape[0]
- */
-
-/* Python wrapper */
-static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/
-static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) {
-  Py_ssize_t __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__len__ (wrapper)", 0);
-  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  Py_ssize_t __pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  __Pyx_RefNannySetupContext("__len__", 0);
-
-  /* "View.MemoryView":606
- * 
- *     def __len__(self):
- *         if self.view.ndim >= 1:             # <<<<<<<<<<<<<<
- *             return self.view.shape[0]
- * 
- */
-  __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":607
- *     def __len__(self):
- *         if self.view.ndim >= 1:
- *             return self.view.shape[0]             # <<<<<<<<<<<<<<
- * 
- *         return 0
- */
-    __pyx_r = (__pyx_v_self->view.shape[0]);
-    goto __pyx_L0;
-
-    /* "View.MemoryView":606
- * 
- *     def __len__(self):
- *         if self.view.ndim >= 1:             # <<<<<<<<<<<<<<
- *             return self.view.shape[0]
- * 
- */
-  }
-
-  /* "View.MemoryView":609
- *             return self.view.shape[0]
- * 
- *         return 0             # <<<<<<<<<<<<<<
- * 
- *     def __repr__(self):
- */
-  __pyx_r = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":605
- *         return self._size
- * 
- *     def __len__(self):             # <<<<<<<<<<<<<<
- *         if self.view.ndim >= 1:
- *             return self.view.shape[0]
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":611
- *         return 0
- * 
- *     def __repr__(self):             # <<<<<<<<<<<<<<
- *         return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__,
- *                                                id(self))
- */
-
-/* Python wrapper */
-static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
-  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__repr__", 0);
-
-  /* "View.MemoryView":612
- * 
- *     def __repr__(self):
- *         return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__,             # <<<<<<<<<<<<<<
- *                                                id(self))
- * 
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 612, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 612, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 612, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  /* "View.MemoryView":613
- *     def __repr__(self):
- *         return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__,
- *                                                id(self))             # <<<<<<<<<<<<<<
- * 
- *     def __str__(self):
- */
-  __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 613, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-
-  /* "View.MemoryView":612
- * 
- *     def __repr__(self):
- *         return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__,             # <<<<<<<<<<<<<<
- *                                                id(self))
- * 
- */
-  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 612, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
-  __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 612, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":611
- *         return 0
- * 
- *     def __repr__(self):             # <<<<<<<<<<<<<<
- *         return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__,
- *                                                id(self))
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":615
- *                                                id(self))
- * 
- *     def __str__(self):             # <<<<<<<<<<<<<<
- *         return "<MemoryView of %r object>" % (self.base.__class__.__name__,)
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
-  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__str__", 0);
-
-  /* "View.MemoryView":616
- * 
- *     def __str__(self):
- *         return "<MemoryView of %r object>" % (self.base.__class__.__name__,)             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 616, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 616, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":615
- *                                                id(self))
- * 
- *     def __str__(self):             # <<<<<<<<<<<<<<
- *         return "<MemoryView of %r object>" % (self.base.__class__.__name__,)
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":619
- * 
- * 
- *     def is_c_contig(self):             # <<<<<<<<<<<<<<
- *         cdef __Pyx_memviewslice *mslice
- *         cdef __Pyx_memviewslice tmp
- */
-
-/* Python wrapper */
-static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0);
-  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) {
-  __Pyx_memviewslice *__pyx_v_mslice;
-  __Pyx_memviewslice __pyx_v_tmp;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_memviewslice *__pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("is_c_contig", 0);
-
-  /* "View.MemoryView":622
- *         cdef __Pyx_memviewslice *mslice
- *         cdef __Pyx_memviewslice tmp
- *         mslice = get_slice_from_memview(self, &tmp)             # <<<<<<<<<<<<<<
- *         return slice_is_contig(mslice[0], 'C', self.view.ndim)
- * 
- */
-  __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 622, __pyx_L1_error)
-  __pyx_v_mslice = __pyx_t_1;
-
-  /* "View.MemoryView":623
- *         cdef __Pyx_memviewslice tmp
- *         mslice = get_slice_from_memview(self, &tmp)
- *         return slice_is_contig(mslice[0], 'C', self.view.ndim)             # <<<<<<<<<<<<<<
- * 
- *     def is_f_contig(self):
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 623, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":619
- * 
- * 
- *     def is_c_contig(self):             # <<<<<<<<<<<<<<
- *         cdef __Pyx_memviewslice *mslice
- *         cdef __Pyx_memviewslice tmp
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":625
- *         return slice_is_contig(mslice[0], 'C', self.view.ndim)
- * 
- *     def is_f_contig(self):             # <<<<<<<<<<<<<<
- *         cdef __Pyx_memviewslice *mslice
- *         cdef __Pyx_memviewslice tmp
- */
-
-/* Python wrapper */
-static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0);
-  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) {
-  __Pyx_memviewslice *__pyx_v_mslice;
-  __Pyx_memviewslice __pyx_v_tmp;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_memviewslice *__pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("is_f_contig", 0);
-
-  /* "View.MemoryView":628
- *         cdef __Pyx_memviewslice *mslice
- *         cdef __Pyx_memviewslice tmp
- *         mslice = get_slice_from_memview(self, &tmp)             # <<<<<<<<<<<<<<
- *         return slice_is_contig(mslice[0], 'F', self.view.ndim)
- * 
- */
-  __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 628, __pyx_L1_error)
-  __pyx_v_mslice = __pyx_t_1;
-
-  /* "View.MemoryView":629
- *         cdef __Pyx_memviewslice tmp
- *         mslice = get_slice_from_memview(self, &tmp)
- *         return slice_is_contig(mslice[0], 'F', self.view.ndim)             # <<<<<<<<<<<<<<
- * 
- *     def copy(self):
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 629, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":625
- *         return slice_is_contig(mslice[0], 'C', self.view.ndim)
- * 
- *     def is_f_contig(self):             # <<<<<<<<<<<<<<
- *         cdef __Pyx_memviewslice *mslice
- *         cdef __Pyx_memviewslice tmp
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":631
- *         return slice_is_contig(mslice[0], 'F', self.view.ndim)
- * 
- *     def copy(self):             # <<<<<<<<<<<<<<
- *         cdef __Pyx_memviewslice mslice
- *         cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
- */
-
-/* Python wrapper */
-static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("copy (wrapper)", 0);
-  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) {
-  __Pyx_memviewslice __pyx_v_mslice;
-  int __pyx_v_flags;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_memviewslice __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("copy", 0);
-
-  /* "View.MemoryView":633
- *     def copy(self):
- *         cdef __Pyx_memviewslice mslice
- *         cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS             # <<<<<<<<<<<<<<
- * 
- *         slice_copy(self, &mslice)
- */
-  __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS));
-
-  /* "View.MemoryView":635
- *         cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
- * 
- *         slice_copy(self, &mslice)             # <<<<<<<<<<<<<<
- *         mslice = slice_copy_contig(&mslice, "c", self.view.ndim,
- *                                    self.view.itemsize,
- */
-  __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice));
-
-  /* "View.MemoryView":636
- * 
- *         slice_copy(self, &mslice)
- *         mslice = slice_copy_contig(&mslice, "c", self.view.ndim,             # <<<<<<<<<<<<<<
- *                                    self.view.itemsize,
- *                                    flags|PyBUF_C_CONTIGUOUS,
- */
-  __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 636, __pyx_L1_error)
-  __pyx_v_mslice = __pyx_t_1;
-
-  /* "View.MemoryView":641
- *                                    self.dtype_is_object)
- * 
- *         return memoryview_copy_from_slice(self, &mslice)             # <<<<<<<<<<<<<<
- * 
- *     def copy_fortran(self):
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 641, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":631
- *         return slice_is_contig(mslice[0], 'F', self.view.ndim)
- * 
- *     def copy(self):             # <<<<<<<<<<<<<<
- *         cdef __Pyx_memviewslice mslice
- *         cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":643
- *         return memoryview_copy_from_slice(self, &mslice)
- * 
- *     def copy_fortran(self):             # <<<<<<<<<<<<<<
- *         cdef __Pyx_memviewslice src, dst
- *         cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
- */
-
-/* Python wrapper */
-static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0);
-  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) {
-  __Pyx_memviewslice __pyx_v_src;
-  __Pyx_memviewslice __pyx_v_dst;
-  int __pyx_v_flags;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_memviewslice __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("copy_fortran", 0);
-
-  /* "View.MemoryView":645
- *     def copy_fortran(self):
- *         cdef __Pyx_memviewslice src, dst
- *         cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS             # <<<<<<<<<<<<<<
- * 
- *         slice_copy(self, &src)
- */
-  __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS));
-
-  /* "View.MemoryView":647
- *         cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
- * 
- *         slice_copy(self, &src)             # <<<<<<<<<<<<<<
- *         dst = slice_copy_contig(&src, "fortran", self.view.ndim,
- *                                 self.view.itemsize,
- */
-  __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src));
-
-  /* "View.MemoryView":648
- * 
- *         slice_copy(self, &src)
- *         dst = slice_copy_contig(&src, "fortran", self.view.ndim,             # <<<<<<<<<<<<<<
- *                                 self.view.itemsize,
- *                                 flags|PyBUF_F_CONTIGUOUS,
- */
-  __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 648, __pyx_L1_error)
-  __pyx_v_dst = __pyx_t_1;
-
-  /* "View.MemoryView":653
- *                                 self.dtype_is_object)
- * 
- *         return memoryview_copy_from_slice(self, &dst)             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 653, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":643
- *         return memoryview_copy_from_slice(self, &mslice)
- * 
- *     def copy_fortran(self):             # <<<<<<<<<<<<<<
- *         cdef __Pyx_memviewslice src, dst
- *         cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
-
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(1, 2, __pyx_L1_error)
-
-  /* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(1, 4, __pyx_L1_error)
-
-  /* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":657
- * 
- * @cname('__pyx_memoryview_new')
- * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):             # <<<<<<<<<<<<<<
- *     cdef memoryview result = memoryview(o, flags, dtype_is_object)
- *     result.typeinfo = typeinfo
- */
-
-static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) {
-  struct __pyx_memoryview_obj *__pyx_v_result = 0;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("memoryview_cwrapper", 0);
-
-  /* "View.MemoryView":658
- * @cname('__pyx_memoryview_new')
- * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):
- *     cdef memoryview result = memoryview(o, flags, dtype_is_object)             # <<<<<<<<<<<<<<
- *     result.typeinfo = typeinfo
- *     return result
- */
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 658, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 658, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 658, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_INCREF(__pyx_v_o);
-  __Pyx_GIVEREF(__pyx_v_o);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
-  __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 658, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2);
-  __pyx_t_2 = 0;
-
-  /* "View.MemoryView":659
- * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):
- *     cdef memoryview result = memoryview(o, flags, dtype_is_object)
- *     result.typeinfo = typeinfo             # <<<<<<<<<<<<<<
- *     return result
- * 
- */
-  __pyx_v_result->typeinfo = __pyx_v_typeinfo;
-
-  /* "View.MemoryView":660
- *     cdef memoryview result = memoryview(o, flags, dtype_is_object)
- *     result.typeinfo = typeinfo
- *     return result             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_memoryview_check')
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_result));
-  __pyx_r = ((PyObject *)__pyx_v_result);
-  goto __pyx_L0;
-
-  /* "View.MemoryView":657
- * 
- * @cname('__pyx_memoryview_new')
- * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):             # <<<<<<<<<<<<<<
- *     cdef memoryview result = memoryview(o, flags, dtype_is_object)
- *     result.typeinfo = typeinfo
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_result);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":663
- * 
- * @cname('__pyx_memoryview_check')
- * cdef inline bint memoryview_check(object o):             # <<<<<<<<<<<<<<
- *     return isinstance(o, memoryview)
- * 
- */
-
-static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  __Pyx_RefNannySetupContext("memoryview_check", 0);
-
-  /* "View.MemoryView":664
- * @cname('__pyx_memoryview_check')
- * cdef inline bint memoryview_check(object o):
- *     return isinstance(o, memoryview)             # <<<<<<<<<<<<<<
- * 
- * cdef tuple _unellipsify(object index, int ndim):
- */
-  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); 
-  __pyx_r = __pyx_t_1;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":663
- * 
- * @cname('__pyx_memoryview_check')
- * cdef inline bint memoryview_check(object o):             # <<<<<<<<<<<<<<
- *     return isinstance(o, memoryview)
- * 
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":666
- *     return isinstance(o, memoryview)
- * 
- * cdef tuple _unellipsify(object index, int ndim):             # <<<<<<<<<<<<<<
- *     """
- *     Replace all ellipses with full slices and fill incomplete indices with
- */
-
-static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) {
-  PyObject *__pyx_v_tup = NULL;
-  PyObject *__pyx_v_result = NULL;
-  int __pyx_v_have_slices;
-  int __pyx_v_seen_ellipsis;
-  CYTHON_UNUSED PyObject *__pyx_v_idx = NULL;
-  PyObject *__pyx_v_item = NULL;
-  Py_ssize_t __pyx_v_nslices;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  Py_ssize_t __pyx_t_5;
-  PyObject *(*__pyx_t_6)(PyObject *);
-  PyObject *__pyx_t_7 = NULL;
-  Py_ssize_t __pyx_t_8;
-  int __pyx_t_9;
-  int __pyx_t_10;
-  PyObject *__pyx_t_11 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("_unellipsify", 0);
-
-  /* "View.MemoryView":671
- *     full slices.
- *     """
- *     if not isinstance(index, tuple):             # <<<<<<<<<<<<<<
- *         tup = (index,)
- *     else:
- */
-  __pyx_t_1 = PyTuple_Check(__pyx_v_index); 
-  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":672
- *     """
- *     if not isinstance(index, tuple):
- *         tup = (index,)             # <<<<<<<<<<<<<<
- *     else:
- *         tup = index
- */
-    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 672, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_INCREF(__pyx_v_index);
-    __Pyx_GIVEREF(__pyx_v_index);
-    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index);
-    __pyx_v_tup = __pyx_t_3;
-    __pyx_t_3 = 0;
-
-    /* "View.MemoryView":671
- *     full slices.
- *     """
- *     if not isinstance(index, tuple):             # <<<<<<<<<<<<<<
- *         tup = (index,)
- *     else:
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":674
- *         tup = (index,)
- *     else:
- *         tup = index             # <<<<<<<<<<<<<<
- * 
- *     result = []
- */
-  /*else*/ {
-    __Pyx_INCREF(__pyx_v_index);
-    __pyx_v_tup = __pyx_v_index;
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":676
- *         tup = index
- * 
- *     result = []             # <<<<<<<<<<<<<<
- *     have_slices = False
- *     seen_ellipsis = False
- */
-  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 676, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_v_result = ((PyObject*)__pyx_t_3);
-  __pyx_t_3 = 0;
-
-  /* "View.MemoryView":677
- * 
- *     result = []
- *     have_slices = False             # <<<<<<<<<<<<<<
- *     seen_ellipsis = False
- *     for idx, item in enumerate(tup):
- */
-  __pyx_v_have_slices = 0;
-
-  /* "View.MemoryView":678
- *     result = []
- *     have_slices = False
- *     seen_ellipsis = False             # <<<<<<<<<<<<<<
- *     for idx, item in enumerate(tup):
- *         if item is Ellipsis:
- */
-  __pyx_v_seen_ellipsis = 0;
-
-  /* "View.MemoryView":679
- *     have_slices = False
- *     seen_ellipsis = False
- *     for idx, item in enumerate(tup):             # <<<<<<<<<<<<<<
- *         if item is Ellipsis:
- *             if not seen_ellipsis:
- */
-  __Pyx_INCREF(__pyx_int_0);
-  __pyx_t_3 = __pyx_int_0;
-  if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) {
-    __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0;
-    __pyx_t_6 = NULL;
-  } else {
-    __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 679, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 679, __pyx_L1_error)
-  }
-  for (;;) {
-    if (likely(!__pyx_t_6)) {
-      if (likely(PyList_CheckExact(__pyx_t_4))) {
-        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 679, __pyx_L1_error)
-        #else
-        __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 679, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_7);
-        #endif
-      } else {
-        if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 679, __pyx_L1_error)
-        #else
-        __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 679, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_7);
-        #endif
-      }
-    } else {
-      __pyx_t_7 = __pyx_t_6(__pyx_t_4);
-      if (unlikely(!__pyx_t_7)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 679, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_7);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7);
-    __pyx_t_7 = 0;
-    __Pyx_INCREF(__pyx_t_3);
-    __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3);
-    __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 679, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    __Pyx_DECREF(__pyx_t_3);
-    __pyx_t_3 = __pyx_t_7;
-    __pyx_t_7 = 0;
-
-    /* "View.MemoryView":680
- *     seen_ellipsis = False
- *     for idx, item in enumerate(tup):
- *         if item is Ellipsis:             # <<<<<<<<<<<<<<
- *             if not seen_ellipsis:
- *                 result.extend([slice(None)] * (ndim - len(tup) + 1))
- */
-    __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis);
-    __pyx_t_1 = (__pyx_t_2 != 0);
-    if (__pyx_t_1) {
-
-      /* "View.MemoryView":681
- *     for idx, item in enumerate(tup):
- *         if item is Ellipsis:
- *             if not seen_ellipsis:             # <<<<<<<<<<<<<<
- *                 result.extend([slice(None)] * (ndim - len(tup) + 1))
- *                 seen_ellipsis = True
- */
-      __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0);
-      if (__pyx_t_1) {
-
-        /* "View.MemoryView":682
- *         if item is Ellipsis:
- *             if not seen_ellipsis:
- *                 result.extend([slice(None)] * (ndim - len(tup) + 1))             # <<<<<<<<<<<<<<
- *                 seen_ellipsis = True
- *             else:
- */
-        __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 682, __pyx_L1_error)
-        __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 682, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_7);
-        { Py_ssize_t __pyx_temp;
-          for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) {
-            __Pyx_INCREF(__pyx_slice__16);
-            __Pyx_GIVEREF(__pyx_slice__16);
-            PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__16);
-          }
-        }
-        __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 682, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-
-        /* "View.MemoryView":683
- *             if not seen_ellipsis:
- *                 result.extend([slice(None)] * (ndim - len(tup) + 1))
- *                 seen_ellipsis = True             # <<<<<<<<<<<<<<
- *             else:
- *                 result.append(slice(None))
- */
-        __pyx_v_seen_ellipsis = 1;
-
-        /* "View.MemoryView":681
- *     for idx, item in enumerate(tup):
- *         if item is Ellipsis:
- *             if not seen_ellipsis:             # <<<<<<<<<<<<<<
- *                 result.extend([slice(None)] * (ndim - len(tup) + 1))
- *                 seen_ellipsis = True
- */
-        goto __pyx_L7;
-      }
-
-      /* "View.MemoryView":685
- *                 seen_ellipsis = True
- *             else:
- *                 result.append(slice(None))             # <<<<<<<<<<<<<<
- *             have_slices = True
- *         else:
- */
-      /*else*/ {
-        __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__16); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 685, __pyx_L1_error)
-      }
-      __pyx_L7:;
-
-      /* "View.MemoryView":686
- *             else:
- *                 result.append(slice(None))
- *             have_slices = True             # <<<<<<<<<<<<<<
- *         else:
- *             if not isinstance(item, slice) and not PyIndex_Check(item):
- */
-      __pyx_v_have_slices = 1;
-
-      /* "View.MemoryView":680
- *     seen_ellipsis = False
- *     for idx, item in enumerate(tup):
- *         if item is Ellipsis:             # <<<<<<<<<<<<<<
- *             if not seen_ellipsis:
- *                 result.extend([slice(None)] * (ndim - len(tup) + 1))
- */
-      goto __pyx_L6;
-    }
-
-    /* "View.MemoryView":688
- *             have_slices = True
- *         else:
- *             if not isinstance(item, slice) and not PyIndex_Check(item):             # <<<<<<<<<<<<<<
- *                 raise TypeError("Cannot index with type '%s'" % type(item))
- * 
- */
-    /*else*/ {
-      __pyx_t_2 = PySlice_Check(__pyx_v_item); 
-      __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0);
-      if (__pyx_t_10) {
-      } else {
-        __pyx_t_1 = __pyx_t_10;
-        goto __pyx_L9_bool_binop_done;
-      }
-      __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0);
-      __pyx_t_1 = __pyx_t_10;
-      __pyx_L9_bool_binop_done:;
-      if (unlikely(__pyx_t_1)) {
-
-        /* "View.MemoryView":689
- *         else:
- *             if not isinstance(item, slice) and not PyIndex_Check(item):
- *                 raise TypeError("Cannot index with type '%s'" % type(item))             # <<<<<<<<<<<<<<
- * 
- *             have_slices = have_slices or isinstance(item, slice)
- */
-        __pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 689, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_7);
-        __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 689, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_11);
-        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-        __Pyx_Raise(__pyx_t_11, 0, 0, 0);
-        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-        __PYX_ERR(1, 689, __pyx_L1_error)
-
-        /* "View.MemoryView":688
- *             have_slices = True
- *         else:
- *             if not isinstance(item, slice) and not PyIndex_Check(item):             # <<<<<<<<<<<<<<
- *                 raise TypeError("Cannot index with type '%s'" % type(item))
- * 
- */
-      }
-
-      /* "View.MemoryView":691
- *                 raise TypeError("Cannot index with type '%s'" % type(item))
- * 
- *             have_slices = have_slices or isinstance(item, slice)             # <<<<<<<<<<<<<<
- *             result.append(item)
- * 
- */
-      __pyx_t_10 = (__pyx_v_have_slices != 0);
-      if (!__pyx_t_10) {
-      } else {
-        __pyx_t_1 = __pyx_t_10;
-        goto __pyx_L11_bool_binop_done;
-      }
-      __pyx_t_10 = PySlice_Check(__pyx_v_item); 
-      __pyx_t_2 = (__pyx_t_10 != 0);
-      __pyx_t_1 = __pyx_t_2;
-      __pyx_L11_bool_binop_done:;
-      __pyx_v_have_slices = __pyx_t_1;
-
-      /* "View.MemoryView":692
- * 
- *             have_slices = have_slices or isinstance(item, slice)
- *             result.append(item)             # <<<<<<<<<<<<<<
- * 
- *     nslices = ndim - len(result)
- */
-      __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 692, __pyx_L1_error)
-    }
-    __pyx_L6:;
-
-    /* "View.MemoryView":679
- *     have_slices = False
- *     seen_ellipsis = False
- *     for idx, item in enumerate(tup):             # <<<<<<<<<<<<<<
- *         if item is Ellipsis:
- *             if not seen_ellipsis:
- */
-  }
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  /* "View.MemoryView":694
- *             result.append(item)
- * 
- *     nslices = ndim - len(result)             # <<<<<<<<<<<<<<
- *     if nslices:
- *         result.extend([slice(None)] * nslices)
- */
-  __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 694, __pyx_L1_error)
-  __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5);
-
-  /* "View.MemoryView":695
- * 
- *     nslices = ndim - len(result)
- *     if nslices:             # <<<<<<<<<<<<<<
- *         result.extend([slice(None)] * nslices)
- * 
- */
-  __pyx_t_1 = (__pyx_v_nslices != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":696
- *     nslices = ndim - len(result)
- *     if nslices:
- *         result.extend([slice(None)] * nslices)             # <<<<<<<<<<<<<<
- * 
- *     return have_slices or nslices, tuple(result)
- */
-    __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 696, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    { Py_ssize_t __pyx_temp;
-      for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) {
-        __Pyx_INCREF(__pyx_slice__16);
-        __Pyx_GIVEREF(__pyx_slice__16);
-        PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__16);
-      }
-    }
-    __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 696, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-    /* "View.MemoryView":695
- * 
- *     nslices = ndim - len(result)
- *     if nslices:             # <<<<<<<<<<<<<<
- *         result.extend([slice(None)] * nslices)
- * 
- */
-  }
-
-  /* "View.MemoryView":698
- *         result.extend([slice(None)] * nslices)
- * 
- *     return have_slices or nslices, tuple(result)             # <<<<<<<<<<<<<<
- * 
- * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
- */
-  __Pyx_XDECREF(__pyx_r);
-  if (!__pyx_v_have_slices) {
-  } else {
-    __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 698, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_3 = __pyx_t_4;
-    __pyx_t_4 = 0;
-    goto __pyx_L14_bool_binop_done;
-  }
-  __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 698, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_3 = __pyx_t_4;
-  __pyx_t_4 = 0;
-  __pyx_L14_bool_binop_done:;
-  __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 698, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 698, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_11);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_4);
-  PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4);
-  __pyx_t_3 = 0;
-  __pyx_t_4 = 0;
-  __pyx_r = ((PyObject*)__pyx_t_11);
-  __pyx_t_11 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":666
- *     return isinstance(o, memoryview)
- * 
- * cdef tuple _unellipsify(object index, int ndim):             # <<<<<<<<<<<<<<
- *     """
- *     Replace all ellipses with full slices and fill incomplete indices with
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_11);
-  __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_tup);
-  __Pyx_XDECREF(__pyx_v_result);
-  __Pyx_XDECREF(__pyx_v_idx);
-  __Pyx_XDECREF(__pyx_v_item);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":700
- *     return have_slices or nslices, tuple(result)
- * 
- * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):             # <<<<<<<<<<<<<<
- *     for suboffset in suboffsets[:ndim]:
- *         if suboffset >= 0:
- */
-
-static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) {
-  Py_ssize_t __pyx_v_suboffset;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  Py_ssize_t *__pyx_t_1;
-  Py_ssize_t *__pyx_t_2;
-  Py_ssize_t *__pyx_t_3;
-  int __pyx_t_4;
-  PyObject *__pyx_t_5 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("assert_direct_dimensions", 0);
-
-  /* "View.MemoryView":701
- * 
- * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
- *     for suboffset in suboffsets[:ndim]:             # <<<<<<<<<<<<<<
- *         if suboffset >= 0:
- *             raise ValueError("Indirect dimensions not supported")
- */
-  __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim);
-  for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) {
-    __pyx_t_1 = __pyx_t_3;
-    __pyx_v_suboffset = (__pyx_t_1[0]);
-
-    /* "View.MemoryView":702
- * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
- *     for suboffset in suboffsets[:ndim]:
- *         if suboffset >= 0:             # <<<<<<<<<<<<<<
- *             raise ValueError("Indirect dimensions not supported")
- * 
- */
-    __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0);
-    if (unlikely(__pyx_t_4)) {
-
-      /* "View.MemoryView":703
- *     for suboffset in suboffsets[:ndim]:
- *         if suboffset >= 0:
- *             raise ValueError("Indirect dimensions not supported")             # <<<<<<<<<<<<<<
- * 
- * 
- */
-      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 703, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_Raise(__pyx_t_5, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __PYX_ERR(1, 703, __pyx_L1_error)
-
-      /* "View.MemoryView":702
- * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
- *     for suboffset in suboffsets[:ndim]:
- *         if suboffset >= 0:             # <<<<<<<<<<<<<<
- *             raise ValueError("Indirect dimensions not supported")
- * 
- */
-    }
-  }
-
-  /* "View.MemoryView":700
- *     return have_slices or nslices, tuple(result)
- * 
- * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):             # <<<<<<<<<<<<<<
- *     for suboffset in suboffsets[:ndim]:
- *         if suboffset >= 0:
- */
-
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":710
- * 
- * @cname('__pyx_memview_slice')
- * cdef memoryview memview_slice(memoryview memview, object indices):             # <<<<<<<<<<<<<<
- *     cdef int new_ndim = 0, suboffset_dim = -1, dim
- *     cdef bint negative_step
- */
-
-static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) {
-  int __pyx_v_new_ndim;
-  int __pyx_v_suboffset_dim;
-  int __pyx_v_dim;
-  __Pyx_memviewslice __pyx_v_src;
-  __Pyx_memviewslice __pyx_v_dst;
-  __Pyx_memviewslice *__pyx_v_p_src;
-  struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0;
-  __Pyx_memviewslice *__pyx_v_p_dst;
-  int *__pyx_v_p_suboffset_dim;
-  Py_ssize_t __pyx_v_start;
-  Py_ssize_t __pyx_v_stop;
-  Py_ssize_t __pyx_v_step;
-  int __pyx_v_have_start;
-  int __pyx_v_have_stop;
-  int __pyx_v_have_step;
-  PyObject *__pyx_v_index = NULL;
-  struct __pyx_memoryview_obj *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  struct __pyx_memoryview_obj *__pyx_t_4;
-  char *__pyx_t_5;
-  int __pyx_t_6;
-  Py_ssize_t __pyx_t_7;
-  PyObject *(*__pyx_t_8)(PyObject *);
-  PyObject *__pyx_t_9 = NULL;
-  Py_ssize_t __pyx_t_10;
-  int __pyx_t_11;
-  Py_ssize_t __pyx_t_12;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("memview_slice", 0);
-
-  /* "View.MemoryView":711
- * @cname('__pyx_memview_slice')
- * cdef memoryview memview_slice(memoryview memview, object indices):
- *     cdef int new_ndim = 0, suboffset_dim = -1, dim             # <<<<<<<<<<<<<<
- *     cdef bint negative_step
- *     cdef __Pyx_memviewslice src, dst
- */
-  __pyx_v_new_ndim = 0;
-  __pyx_v_suboffset_dim = -1;
-
-  /* "View.MemoryView":718
- * 
- * 
- *     memset(&dst, 0, sizeof(dst))             # <<<<<<<<<<<<<<
- * 
- *     cdef _memoryviewslice memviewsliceobj
- */
-  (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst))));
-
-  /* "View.MemoryView":722
- *     cdef _memoryviewslice memviewsliceobj
- * 
- *     assert memview.view.ndim > 0             # <<<<<<<<<<<<<<
- * 
- *     if isinstance(memview, _memoryviewslice):
- */
-  #ifndef CYTHON_WITHOUT_ASSERTIONS
-  if (unlikely(!Py_OptimizeFlag)) {
-    if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) {
-      PyErr_SetNone(PyExc_AssertionError);
-      __PYX_ERR(1, 722, __pyx_L1_error)
-    }
-  }
-  #endif
-
-  /* "View.MemoryView":724
- *     assert memview.view.ndim > 0
- * 
- *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
- *         memviewsliceobj = memview
- *         p_src = &memviewsliceobj.from_slice
- */
-  __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); 
-  __pyx_t_2 = (__pyx_t_1 != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":725
- * 
- *     if isinstance(memview, _memoryviewslice):
- *         memviewsliceobj = memview             # <<<<<<<<<<<<<<
- *         p_src = &memviewsliceobj.from_slice
- *     else:
- */
-    if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 725, __pyx_L1_error)
-    __pyx_t_3 = ((PyObject *)__pyx_v_memview);
-    __Pyx_INCREF(__pyx_t_3);
-    __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3);
-    __pyx_t_3 = 0;
-
-    /* "View.MemoryView":726
- *     if isinstance(memview, _memoryviewslice):
- *         memviewsliceobj = memview
- *         p_src = &memviewsliceobj.from_slice             # <<<<<<<<<<<<<<
- *     else:
- *         slice_copy(memview, &src)
- */
-    __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice);
-
-    /* "View.MemoryView":724
- *     assert memview.view.ndim > 0
- * 
- *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
- *         memviewsliceobj = memview
- *         p_src = &memviewsliceobj.from_slice
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":728
- *         p_src = &memviewsliceobj.from_slice
- *     else:
- *         slice_copy(memview, &src)             # <<<<<<<<<<<<<<
- *         p_src = &src
- * 
- */
-  /*else*/ {
-    __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src));
-
-    /* "View.MemoryView":729
- *     else:
- *         slice_copy(memview, &src)
- *         p_src = &src             # <<<<<<<<<<<<<<
- * 
- * 
- */
-    __pyx_v_p_src = (&__pyx_v_src);
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":735
- * 
- * 
- *     dst.memview = p_src.memview             # <<<<<<<<<<<<<<
- *     dst.data = p_src.data
- * 
- */
-  __pyx_t_4 = __pyx_v_p_src->memview;
-  __pyx_v_dst.memview = __pyx_t_4;
-
-  /* "View.MemoryView":736
- * 
- *     dst.memview = p_src.memview
- *     dst.data = p_src.data             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_5 = __pyx_v_p_src->data;
-  __pyx_v_dst.data = __pyx_t_5;
-
-  /* "View.MemoryView":741
- * 
- * 
- *     cdef __Pyx_memviewslice *p_dst = &dst             # <<<<<<<<<<<<<<
- *     cdef int *p_suboffset_dim = &suboffset_dim
- *     cdef Py_ssize_t start, stop, step
- */
-  __pyx_v_p_dst = (&__pyx_v_dst);
-
-  /* "View.MemoryView":742
- * 
- *     cdef __Pyx_memviewslice *p_dst = &dst
- *     cdef int *p_suboffset_dim = &suboffset_dim             # <<<<<<<<<<<<<<
- *     cdef Py_ssize_t start, stop, step
- *     cdef bint have_start, have_stop, have_step
- */
-  __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim);
-
-  /* "View.MemoryView":746
- *     cdef bint have_start, have_stop, have_step
- * 
- *     for dim, index in enumerate(indices):             # <<<<<<<<<<<<<<
- *         if PyIndex_Check(index):
- *             slice_memviewslice(
- */
-  __pyx_t_6 = 0;
-  if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) {
-    __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0;
-    __pyx_t_8 = NULL;
-  } else {
-    __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 746, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 746, __pyx_L1_error)
-  }
-  for (;;) {
-    if (likely(!__pyx_t_8)) {
-      if (likely(PyList_CheckExact(__pyx_t_3))) {
-        if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 746, __pyx_L1_error)
-        #else
-        __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 746, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        #endif
-      } else {
-        if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 746, __pyx_L1_error)
-        #else
-        __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 746, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        #endif
-      }
-    } else {
-      __pyx_t_9 = __pyx_t_8(__pyx_t_3);
-      if (unlikely(!__pyx_t_9)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 746, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_9);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9);
-    __pyx_t_9 = 0;
-    __pyx_v_dim = __pyx_t_6;
-    __pyx_t_6 = (__pyx_t_6 + 1);
-
-    /* "View.MemoryView":747
- * 
- *     for dim, index in enumerate(indices):
- *         if PyIndex_Check(index):             # <<<<<<<<<<<<<<
- *             slice_memviewslice(
- *                 p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
- */
-    __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":751
- *                 p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
- *                 dim, new_ndim, p_suboffset_dim,
- *                 index, 0, 0, # start, stop, step             # <<<<<<<<<<<<<<
- *                 0, 0, 0, # have_{start,stop,step}
- *                 False)
- */
-      __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 751, __pyx_L1_error)
-
-      /* "View.MemoryView":748
- *     for dim, index in enumerate(indices):
- *         if PyIndex_Check(index):
- *             slice_memviewslice(             # <<<<<<<<<<<<<<
- *                 p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
- *                 dim, new_ndim, p_suboffset_dim,
- */
-      __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 748, __pyx_L1_error)
-
-      /* "View.MemoryView":747
- * 
- *     for dim, index in enumerate(indices):
- *         if PyIndex_Check(index):             # <<<<<<<<<<<<<<
- *             slice_memviewslice(
- *                 p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
- */
-      goto __pyx_L6;
-    }
-
-    /* "View.MemoryView":754
- *                 0, 0, 0, # have_{start,stop,step}
- *                 False)
- *         elif index is None:             # <<<<<<<<<<<<<<
- *             p_dst.shape[new_ndim] = 1
- *             p_dst.strides[new_ndim] = 0
- */
-    __pyx_t_2 = (__pyx_v_index == Py_None);
-    __pyx_t_1 = (__pyx_t_2 != 0);
-    if (__pyx_t_1) {
-
-      /* "View.MemoryView":755
- *                 False)
- *         elif index is None:
- *             p_dst.shape[new_ndim] = 1             # <<<<<<<<<<<<<<
- *             p_dst.strides[new_ndim] = 0
- *             p_dst.suboffsets[new_ndim] = -1
- */
-      (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1;
-
-      /* "View.MemoryView":756
- *         elif index is None:
- *             p_dst.shape[new_ndim] = 1
- *             p_dst.strides[new_ndim] = 0             # <<<<<<<<<<<<<<
- *             p_dst.suboffsets[new_ndim] = -1
- *             new_ndim += 1
- */
-      (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0;
-
-      /* "View.MemoryView":757
- *             p_dst.shape[new_ndim] = 1
- *             p_dst.strides[new_ndim] = 0
- *             p_dst.suboffsets[new_ndim] = -1             # <<<<<<<<<<<<<<
- *             new_ndim += 1
- *         else:
- */
-      (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L;
-
-      /* "View.MemoryView":758
- *             p_dst.strides[new_ndim] = 0
- *             p_dst.suboffsets[new_ndim] = -1
- *             new_ndim += 1             # <<<<<<<<<<<<<<
- *         else:
- *             start = index.start or 0
- */
-      __pyx_v_new_ndim = (__pyx_v_new_ndim + 1);
-
-      /* "View.MemoryView":754
- *                 0, 0, 0, # have_{start,stop,step}
- *                 False)
- *         elif index is None:             # <<<<<<<<<<<<<<
- *             p_dst.shape[new_ndim] = 1
- *             p_dst.strides[new_ndim] = 0
- */
-      goto __pyx_L6;
-    }
-
-    /* "View.MemoryView":760
- *             new_ndim += 1
- *         else:
- *             start = index.start or 0             # <<<<<<<<<<<<<<
- *             stop = index.stop or 0
- *             step = index.step or 0
- */
-    /*else*/ {
-      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 760, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 760, __pyx_L1_error)
-      if (!__pyx_t_1) {
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      } else {
-        __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 760, __pyx_L1_error)
-        __pyx_t_10 = __pyx_t_12;
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        goto __pyx_L7_bool_binop_done;
-      }
-      __pyx_t_10 = 0;
-      __pyx_L7_bool_binop_done:;
-      __pyx_v_start = __pyx_t_10;
-
-      /* "View.MemoryView":761
- *         else:
- *             start = index.start or 0
- *             stop = index.stop or 0             # <<<<<<<<<<<<<<
- *             step = index.step or 0
- * 
- */
-      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 761, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 761, __pyx_L1_error)
-      if (!__pyx_t_1) {
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      } else {
-        __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 761, __pyx_L1_error)
-        __pyx_t_10 = __pyx_t_12;
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        goto __pyx_L9_bool_binop_done;
-      }
-      __pyx_t_10 = 0;
-      __pyx_L9_bool_binop_done:;
-      __pyx_v_stop = __pyx_t_10;
-
-      /* "View.MemoryView":762
- *             start = index.start or 0
- *             stop = index.stop or 0
- *             step = index.step or 0             # <<<<<<<<<<<<<<
- * 
- *             have_start = index.start is not None
- */
-      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 762, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 762, __pyx_L1_error)
-      if (!__pyx_t_1) {
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      } else {
-        __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error)
-        __pyx_t_10 = __pyx_t_12;
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        goto __pyx_L11_bool_binop_done;
-      }
-      __pyx_t_10 = 0;
-      __pyx_L11_bool_binop_done:;
-      __pyx_v_step = __pyx_t_10;
-
-      /* "View.MemoryView":764
- *             step = index.step or 0
- * 
- *             have_start = index.start is not None             # <<<<<<<<<<<<<<
- *             have_stop = index.stop is not None
- *             have_step = index.step is not None
- */
-      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 764, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_1 = (__pyx_t_9 != Py_None);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_v_have_start = __pyx_t_1;
-
-      /* "View.MemoryView":765
- * 
- *             have_start = index.start is not None
- *             have_stop = index.stop is not None             # <<<<<<<<<<<<<<
- *             have_step = index.step is not None
- * 
- */
-      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 765, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_1 = (__pyx_t_9 != Py_None);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_v_have_stop = __pyx_t_1;
-
-      /* "View.MemoryView":766
- *             have_start = index.start is not None
- *             have_stop = index.stop is not None
- *             have_step = index.step is not None             # <<<<<<<<<<<<<<
- * 
- *             slice_memviewslice(
- */
-      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 766, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_1 = (__pyx_t_9 != Py_None);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_v_have_step = __pyx_t_1;
-
-      /* "View.MemoryView":768
- *             have_step = index.step is not None
- * 
- *             slice_memviewslice(             # <<<<<<<<<<<<<<
- *                 p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
- *                 dim, new_ndim, p_suboffset_dim,
- */
-      __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 768, __pyx_L1_error)
-
-      /* "View.MemoryView":774
- *                 have_start, have_stop, have_step,
- *                 True)
- *             new_ndim += 1             # <<<<<<<<<<<<<<
- * 
- *     if isinstance(memview, _memoryviewslice):
- */
-      __pyx_v_new_ndim = (__pyx_v_new_ndim + 1);
-    }
-    __pyx_L6:;
-
-    /* "View.MemoryView":746
- *     cdef bint have_start, have_stop, have_step
- * 
- *     for dim, index in enumerate(indices):             # <<<<<<<<<<<<<<
- *         if PyIndex_Check(index):
- *             slice_memviewslice(
- */
-  }
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  /* "View.MemoryView":776
- *             new_ndim += 1
- * 
- *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
- *         return memoryview_fromslice(dst, new_ndim,
- *                                     memviewsliceobj.to_object_func,
- */
-  __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); 
-  __pyx_t_2 = (__pyx_t_1 != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":777
- * 
- *     if isinstance(memview, _memoryviewslice):
- *         return memoryview_fromslice(dst, new_ndim,             # <<<<<<<<<<<<<<
- *                                     memviewsliceobj.to_object_func,
- *                                     memviewsliceobj.to_dtype_func,
- */
-    __Pyx_XDECREF(((PyObject *)__pyx_r));
-
-    /* "View.MemoryView":778
- *     if isinstance(memview, _memoryviewslice):
- *         return memoryview_fromslice(dst, new_ndim,
- *                                     memviewsliceobj.to_object_func,             # <<<<<<<<<<<<<<
- *                                     memviewsliceobj.to_dtype_func,
- *                                     memview.dtype_is_object)
- */
-    if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 778, __pyx_L1_error) }
-
-    /* "View.MemoryView":779
- *         return memoryview_fromslice(dst, new_ndim,
- *                                     memviewsliceobj.to_object_func,
- *                                     memviewsliceobj.to_dtype_func,             # <<<<<<<<<<<<<<
- *                                     memview.dtype_is_object)
- *     else:
- */
-    if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 779, __pyx_L1_error) }
-
-    /* "View.MemoryView":777
- * 
- *     if isinstance(memview, _memoryviewslice):
- *         return memoryview_fromslice(dst, new_ndim,             # <<<<<<<<<<<<<<
- *                                     memviewsliceobj.to_object_func,
- *                                     memviewsliceobj.to_dtype_func,
- */
-    __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 777, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 777, __pyx_L1_error)
-    __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3);
-    __pyx_t_3 = 0;
-    goto __pyx_L0;
-
-    /* "View.MemoryView":776
- *             new_ndim += 1
- * 
- *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
- *         return memoryview_fromslice(dst, new_ndim,
- *                                     memviewsliceobj.to_object_func,
- */
-  }
-
-  /* "View.MemoryView":782
- *                                     memview.dtype_is_object)
- *     else:
- *         return memoryview_fromslice(dst, new_ndim, NULL, NULL,             # <<<<<<<<<<<<<<
- *                                     memview.dtype_is_object)
- * 
- */
-  /*else*/ {
-    __Pyx_XDECREF(((PyObject *)__pyx_r));
-
-    /* "View.MemoryView":783
- *     else:
- *         return memoryview_fromslice(dst, new_ndim, NULL, NULL,
- *                                     memview.dtype_is_object)             # <<<<<<<<<<<<<<
- * 
- * 
- */
-    __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 782, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-
-    /* "View.MemoryView":782
- *                                     memview.dtype_is_object)
- *     else:
- *         return memoryview_fromslice(dst, new_ndim, NULL, NULL,             # <<<<<<<<<<<<<<
- *                                     memview.dtype_is_object)
- * 
- */
-    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 782, __pyx_L1_error)
-    __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3);
-    __pyx_t_3 = 0;
-    goto __pyx_L0;
-  }
-
-  /* "View.MemoryView":710
- * 
- * @cname('__pyx_memview_slice')
- * cdef memoryview memview_slice(memoryview memview, object indices):             # <<<<<<<<<<<<<<
- *     cdef int new_ndim = 0, suboffset_dim = -1, dim
- *     cdef bint negative_step
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj);
-  __Pyx_XDECREF(__pyx_v_index);
-  __Pyx_XGIVEREF((PyObject *)__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":807
- * 
- * @cname('__pyx_memoryview_slice_memviewslice')
- * cdef int slice_memviewslice(             # <<<<<<<<<<<<<<
- *         __Pyx_memviewslice *dst,
- *         Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset,
- */
-
-static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) {
-  Py_ssize_t __pyx_v_new_shape;
-  int __pyx_v_negative_step;
-  int __pyx_r;
-  int __pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-
-  /* "View.MemoryView":827
- *     cdef bint negative_step
- * 
- *     if not is_slice:             # <<<<<<<<<<<<<<
- * 
- *         if start < 0:
- */
-  __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":829
- *     if not is_slice:
- * 
- *         if start < 0:             # <<<<<<<<<<<<<<
- *             start += shape
- *         if not 0 <= start < shape:
- */
-    __pyx_t_1 = ((__pyx_v_start < 0) != 0);
-    if (__pyx_t_1) {
-
-      /* "View.MemoryView":830
- * 
- *         if start < 0:
- *             start += shape             # <<<<<<<<<<<<<<
- *         if not 0 <= start < shape:
- *             _err_dim(IndexError, "Index out of bounds (axis %d)", dim)
- */
-      __pyx_v_start = (__pyx_v_start + __pyx_v_shape);
-
-      /* "View.MemoryView":829
- *     if not is_slice:
- * 
- *         if start < 0:             # <<<<<<<<<<<<<<
- *             start += shape
- *         if not 0 <= start < shape:
- */
-    }
-
-    /* "View.MemoryView":831
- *         if start < 0:
- *             start += shape
- *         if not 0 <= start < shape:             # <<<<<<<<<<<<<<
- *             _err_dim(IndexError, "Index out of bounds (axis %d)", dim)
- *     else:
- */
-    __pyx_t_1 = (0 <= __pyx_v_start);
-    if (__pyx_t_1) {
-      __pyx_t_1 = (__pyx_v_start < __pyx_v_shape);
-    }
-    __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":832
- *             start += shape
- *         if not 0 <= start < shape:
- *             _err_dim(IndexError, "Index out of bounds (axis %d)", dim)             # <<<<<<<<<<<<<<
- *     else:
- * 
- */
-      __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 832, __pyx_L1_error)
-
-      /* "View.MemoryView":831
- *         if start < 0:
- *             start += shape
- *         if not 0 <= start < shape:             # <<<<<<<<<<<<<<
- *             _err_dim(IndexError, "Index out of bounds (axis %d)", dim)
- *     else:
- */
-    }
-
-    /* "View.MemoryView":827
- *     cdef bint negative_step
- * 
- *     if not is_slice:             # <<<<<<<<<<<<<<
- * 
- *         if start < 0:
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":835
- *     else:
- * 
- *         negative_step = have_step != 0 and step < 0             # <<<<<<<<<<<<<<
- * 
- *         if have_step and step == 0:
- */
-  /*else*/ {
-    __pyx_t_1 = ((__pyx_v_have_step != 0) != 0);
-    if (__pyx_t_1) {
-    } else {
-      __pyx_t_2 = __pyx_t_1;
-      goto __pyx_L6_bool_binop_done;
-    }
-    __pyx_t_1 = ((__pyx_v_step < 0) != 0);
-    __pyx_t_2 = __pyx_t_1;
-    __pyx_L6_bool_binop_done:;
-    __pyx_v_negative_step = __pyx_t_2;
-
-    /* "View.MemoryView":837
- *         negative_step = have_step != 0 and step < 0
- * 
- *         if have_step and step == 0:             # <<<<<<<<<<<<<<
- *             _err_dim(ValueError, "Step may not be zero (axis %d)", dim)
- * 
- */
-    __pyx_t_1 = (__pyx_v_have_step != 0);
-    if (__pyx_t_1) {
-    } else {
-      __pyx_t_2 = __pyx_t_1;
-      goto __pyx_L9_bool_binop_done;
-    }
-    __pyx_t_1 = ((__pyx_v_step == 0) != 0);
-    __pyx_t_2 = __pyx_t_1;
-    __pyx_L9_bool_binop_done:;
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":838
- * 
- *         if have_step and step == 0:
- *             _err_dim(ValueError, "Step may not be zero (axis %d)", dim)             # <<<<<<<<<<<<<<
- * 
- * 
- */
-      __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 838, __pyx_L1_error)
-
-      /* "View.MemoryView":837
- *         negative_step = have_step != 0 and step < 0
- * 
- *         if have_step and step == 0:             # <<<<<<<<<<<<<<
- *             _err_dim(ValueError, "Step may not be zero (axis %d)", dim)
- * 
- */
-    }
-
-    /* "View.MemoryView":841
- * 
- * 
- *         if have_start:             # <<<<<<<<<<<<<<
- *             if start < 0:
- *                 start += shape
- */
-    __pyx_t_2 = (__pyx_v_have_start != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":842
- * 
- *         if have_start:
- *             if start < 0:             # <<<<<<<<<<<<<<
- *                 start += shape
- *                 if start < 0:
- */
-      __pyx_t_2 = ((__pyx_v_start < 0) != 0);
-      if (__pyx_t_2) {
-
-        /* "View.MemoryView":843
- *         if have_start:
- *             if start < 0:
- *                 start += shape             # <<<<<<<<<<<<<<
- *                 if start < 0:
- *                     start = 0
- */
-        __pyx_v_start = (__pyx_v_start + __pyx_v_shape);
-
-        /* "View.MemoryView":844
- *             if start < 0:
- *                 start += shape
- *                 if start < 0:             # <<<<<<<<<<<<<<
- *                     start = 0
- *             elif start >= shape:
- */
-        __pyx_t_2 = ((__pyx_v_start < 0) != 0);
-        if (__pyx_t_2) {
-
-          /* "View.MemoryView":845
- *                 start += shape
- *                 if start < 0:
- *                     start = 0             # <<<<<<<<<<<<<<
- *             elif start >= shape:
- *                 if negative_step:
- */
-          __pyx_v_start = 0;
-
-          /* "View.MemoryView":844
- *             if start < 0:
- *                 start += shape
- *                 if start < 0:             # <<<<<<<<<<<<<<
- *                     start = 0
- *             elif start >= shape:
- */
-        }
-
-        /* "View.MemoryView":842
- * 
- *         if have_start:
- *             if start < 0:             # <<<<<<<<<<<<<<
- *                 start += shape
- *                 if start < 0:
- */
-        goto __pyx_L12;
-      }
-
-      /* "View.MemoryView":846
- *                 if start < 0:
- *                     start = 0
- *             elif start >= shape:             # <<<<<<<<<<<<<<
- *                 if negative_step:
- *                     start = shape - 1
- */
-      __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0);
-      if (__pyx_t_2) {
-
-        /* "View.MemoryView":847
- *                     start = 0
- *             elif start >= shape:
- *                 if negative_step:             # <<<<<<<<<<<<<<
- *                     start = shape - 1
- *                 else:
- */
-        __pyx_t_2 = (__pyx_v_negative_step != 0);
-        if (__pyx_t_2) {
-
-          /* "View.MemoryView":848
- *             elif start >= shape:
- *                 if negative_step:
- *                     start = shape - 1             # <<<<<<<<<<<<<<
- *                 else:
- *                     start = shape
- */
-          __pyx_v_start = (__pyx_v_shape - 1);
-
-          /* "View.MemoryView":847
- *                     start = 0
- *             elif start >= shape:
- *                 if negative_step:             # <<<<<<<<<<<<<<
- *                     start = shape - 1
- *                 else:
- */
-          goto __pyx_L14;
-        }
-
-        /* "View.MemoryView":850
- *                     start = shape - 1
- *                 else:
- *                     start = shape             # <<<<<<<<<<<<<<
- *         else:
- *             if negative_step:
- */
-        /*else*/ {
-          __pyx_v_start = __pyx_v_shape;
-        }
-        __pyx_L14:;
-
-        /* "View.MemoryView":846
- *                 if start < 0:
- *                     start = 0
- *             elif start >= shape:             # <<<<<<<<<<<<<<
- *                 if negative_step:
- *                     start = shape - 1
- */
-      }
-      __pyx_L12:;
-
-      /* "View.MemoryView":841
- * 
- * 
- *         if have_start:             # <<<<<<<<<<<<<<
- *             if start < 0:
- *                 start += shape
- */
-      goto __pyx_L11;
-    }
-
-    /* "View.MemoryView":852
- *                     start = shape
- *         else:
- *             if negative_step:             # <<<<<<<<<<<<<<
- *                 start = shape - 1
- *             else:
- */
-    /*else*/ {
-      __pyx_t_2 = (__pyx_v_negative_step != 0);
-      if (__pyx_t_2) {
-
-        /* "View.MemoryView":853
- *         else:
- *             if negative_step:
- *                 start = shape - 1             # <<<<<<<<<<<<<<
- *             else:
- *                 start = 0
- */
-        __pyx_v_start = (__pyx_v_shape - 1);
-
-        /* "View.MemoryView":852
- *                     start = shape
- *         else:
- *             if negative_step:             # <<<<<<<<<<<<<<
- *                 start = shape - 1
- *             else:
- */
-        goto __pyx_L15;
-      }
-
-      /* "View.MemoryView":855
- *                 start = shape - 1
- *             else:
- *                 start = 0             # <<<<<<<<<<<<<<
- * 
- *         if have_stop:
- */
-      /*else*/ {
-        __pyx_v_start = 0;
-      }
-      __pyx_L15:;
-    }
-    __pyx_L11:;
-
-    /* "View.MemoryView":857
- *                 start = 0
- * 
- *         if have_stop:             # <<<<<<<<<<<<<<
- *             if stop < 0:
- *                 stop += shape
- */
-    __pyx_t_2 = (__pyx_v_have_stop != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":858
- * 
- *         if have_stop:
- *             if stop < 0:             # <<<<<<<<<<<<<<
- *                 stop += shape
- *                 if stop < 0:
- */
-      __pyx_t_2 = ((__pyx_v_stop < 0) != 0);
-      if (__pyx_t_2) {
-
-        /* "View.MemoryView":859
- *         if have_stop:
- *             if stop < 0:
- *                 stop += shape             # <<<<<<<<<<<<<<
- *                 if stop < 0:
- *                     stop = 0
- */
-        __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape);
-
-        /* "View.MemoryView":860
- *             if stop < 0:
- *                 stop += shape
- *                 if stop < 0:             # <<<<<<<<<<<<<<
- *                     stop = 0
- *             elif stop > shape:
- */
-        __pyx_t_2 = ((__pyx_v_stop < 0) != 0);
-        if (__pyx_t_2) {
-
-          /* "View.MemoryView":861
- *                 stop += shape
- *                 if stop < 0:
- *                     stop = 0             # <<<<<<<<<<<<<<
- *             elif stop > shape:
- *                 stop = shape
- */
-          __pyx_v_stop = 0;
-
-          /* "View.MemoryView":860
- *             if stop < 0:
- *                 stop += shape
- *                 if stop < 0:             # <<<<<<<<<<<<<<
- *                     stop = 0
- *             elif stop > shape:
- */
-        }
-
-        /* "View.MemoryView":858
- * 
- *         if have_stop:
- *             if stop < 0:             # <<<<<<<<<<<<<<
- *                 stop += shape
- *                 if stop < 0:
- */
-        goto __pyx_L17;
-      }
-
-      /* "View.MemoryView":862
- *                 if stop < 0:
- *                     stop = 0
- *             elif stop > shape:             # <<<<<<<<<<<<<<
- *                 stop = shape
- *         else:
- */
-      __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0);
-      if (__pyx_t_2) {
-
-        /* "View.MemoryView":863
- *                     stop = 0
- *             elif stop > shape:
- *                 stop = shape             # <<<<<<<<<<<<<<
- *         else:
- *             if negative_step:
- */
-        __pyx_v_stop = __pyx_v_shape;
-
-        /* "View.MemoryView":862
- *                 if stop < 0:
- *                     stop = 0
- *             elif stop > shape:             # <<<<<<<<<<<<<<
- *                 stop = shape
- *         else:
- */
-      }
-      __pyx_L17:;
-
-      /* "View.MemoryView":857
- *                 start = 0
- * 
- *         if have_stop:             # <<<<<<<<<<<<<<
- *             if stop < 0:
- *                 stop += shape
- */
-      goto __pyx_L16;
-    }
-
-    /* "View.MemoryView":865
- *                 stop = shape
- *         else:
- *             if negative_step:             # <<<<<<<<<<<<<<
- *                 stop = -1
- *             else:
- */
-    /*else*/ {
-      __pyx_t_2 = (__pyx_v_negative_step != 0);
-      if (__pyx_t_2) {
-
-        /* "View.MemoryView":866
- *         else:
- *             if negative_step:
- *                 stop = -1             # <<<<<<<<<<<<<<
- *             else:
- *                 stop = shape
- */
-        __pyx_v_stop = -1L;
-
-        /* "View.MemoryView":865
- *                 stop = shape
- *         else:
- *             if negative_step:             # <<<<<<<<<<<<<<
- *                 stop = -1
- *             else:
- */
-        goto __pyx_L19;
-      }
-
-      /* "View.MemoryView":868
- *                 stop = -1
- *             else:
- *                 stop = shape             # <<<<<<<<<<<<<<
- * 
- *         if not have_step:
- */
-      /*else*/ {
-        __pyx_v_stop = __pyx_v_shape;
-      }
-      __pyx_L19:;
-    }
-    __pyx_L16:;
-
-    /* "View.MemoryView":870
- *                 stop = shape
- * 
- *         if not have_step:             # <<<<<<<<<<<<<<
- *             step = 1
- * 
- */
-    __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":871
- * 
- *         if not have_step:
- *             step = 1             # <<<<<<<<<<<<<<
- * 
- * 
- */
-      __pyx_v_step = 1;
-
-      /* "View.MemoryView":870
- *                 stop = shape
- * 
- *         if not have_step:             # <<<<<<<<<<<<<<
- *             step = 1
- * 
- */
-    }
-
-    /* "View.MemoryView":875
- * 
- *         with cython.cdivision(True):
- *             new_shape = (stop - start) // step             # <<<<<<<<<<<<<<
- * 
- *             if (stop - start) - step * new_shape:
- */
-    __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step);
-
-    /* "View.MemoryView":877
- *             new_shape = (stop - start) // step
- * 
- *             if (stop - start) - step * new_shape:             # <<<<<<<<<<<<<<
- *                 new_shape += 1
- * 
- */
-    __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":878
- * 
- *             if (stop - start) - step * new_shape:
- *                 new_shape += 1             # <<<<<<<<<<<<<<
- * 
- *         if new_shape < 0:
- */
-      __pyx_v_new_shape = (__pyx_v_new_shape + 1);
-
-      /* "View.MemoryView":877
- *             new_shape = (stop - start) // step
- * 
- *             if (stop - start) - step * new_shape:             # <<<<<<<<<<<<<<
- *                 new_shape += 1
- * 
- */
-    }
-
-    /* "View.MemoryView":880
- *                 new_shape += 1
- * 
- *         if new_shape < 0:             # <<<<<<<<<<<<<<
- *             new_shape = 0
- * 
- */
-    __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":881
- * 
- *         if new_shape < 0:
- *             new_shape = 0             # <<<<<<<<<<<<<<
- * 
- * 
- */
-      __pyx_v_new_shape = 0;
-
-      /* "View.MemoryView":880
- *                 new_shape += 1
- * 
- *         if new_shape < 0:             # <<<<<<<<<<<<<<
- *             new_shape = 0
- * 
- */
-    }
-
-    /* "View.MemoryView":884
- * 
- * 
- *         dst.strides[new_ndim] = stride * step             # <<<<<<<<<<<<<<
- *         dst.shape[new_ndim] = new_shape
- *         dst.suboffsets[new_ndim] = suboffset
- */
-    (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step);
-
-    /* "View.MemoryView":885
- * 
- *         dst.strides[new_ndim] = stride * step
- *         dst.shape[new_ndim] = new_shape             # <<<<<<<<<<<<<<
- *         dst.suboffsets[new_ndim] = suboffset
- * 
- */
-    (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape;
-
-    /* "View.MemoryView":886
- *         dst.strides[new_ndim] = stride * step
- *         dst.shape[new_ndim] = new_shape
- *         dst.suboffsets[new_ndim] = suboffset             # <<<<<<<<<<<<<<
- * 
- * 
- */
-    (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset;
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":889
- * 
- * 
- *     if suboffset_dim[0] < 0:             # <<<<<<<<<<<<<<
- *         dst.data += start * stride
- *     else:
- */
-  __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":890
- * 
- *     if suboffset_dim[0] < 0:
- *         dst.data += start * stride             # <<<<<<<<<<<<<<
- *     else:
- *         dst.suboffsets[suboffset_dim[0]] += start * stride
- */
-    __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride));
-
-    /* "View.MemoryView":889
- * 
- * 
- *     if suboffset_dim[0] < 0:             # <<<<<<<<<<<<<<
- *         dst.data += start * stride
- *     else:
- */
-    goto __pyx_L23;
-  }
-
-  /* "View.MemoryView":892
- *         dst.data += start * stride
- *     else:
- *         dst.suboffsets[suboffset_dim[0]] += start * stride             # <<<<<<<<<<<<<<
- * 
- *     if suboffset >= 0:
- */
-  /*else*/ {
-    __pyx_t_3 = (__pyx_v_suboffset_dim[0]);
-    (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride));
-  }
-  __pyx_L23:;
-
-  /* "View.MemoryView":894
- *         dst.suboffsets[suboffset_dim[0]] += start * stride
- * 
- *     if suboffset >= 0:             # <<<<<<<<<<<<<<
- *         if not is_slice:
- *             if new_ndim == 0:
- */
-  __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":895
- * 
- *     if suboffset >= 0:
- *         if not is_slice:             # <<<<<<<<<<<<<<
- *             if new_ndim == 0:
- *                 dst.data = (<char **> dst.data)[0] + suboffset
- */
-    __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":896
- *     if suboffset >= 0:
- *         if not is_slice:
- *             if new_ndim == 0:             # <<<<<<<<<<<<<<
- *                 dst.data = (<char **> dst.data)[0] + suboffset
- *             else:
- */
-      __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0);
-      if (__pyx_t_2) {
-
-        /* "View.MemoryView":897
- *         if not is_slice:
- *             if new_ndim == 0:
- *                 dst.data = (<char **> dst.data)[0] + suboffset             # <<<<<<<<<<<<<<
- *             else:
- *                 _err_dim(IndexError, "All dimensions preceding dimension %d "
- */
-        __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset);
-
-        /* "View.MemoryView":896
- *     if suboffset >= 0:
- *         if not is_slice:
- *             if new_ndim == 0:             # <<<<<<<<<<<<<<
- *                 dst.data = (<char **> dst.data)[0] + suboffset
- *             else:
- */
-        goto __pyx_L26;
-      }
-
-      /* "View.MemoryView":899
- *                 dst.data = (<char **> dst.data)[0] + suboffset
- *             else:
- *                 _err_dim(IndexError, "All dimensions preceding dimension %d "             # <<<<<<<<<<<<<<
- *                                      "must be indexed and not sliced", dim)
- *         else:
- */
-      /*else*/ {
-
-        /* "View.MemoryView":900
- *             else:
- *                 _err_dim(IndexError, "All dimensions preceding dimension %d "
- *                                      "must be indexed and not sliced", dim)             # <<<<<<<<<<<<<<
- *         else:
- *             suboffset_dim[0] = new_ndim
- */
-        __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 899, __pyx_L1_error)
-      }
-      __pyx_L26:;
-
-      /* "View.MemoryView":895
- * 
- *     if suboffset >= 0:
- *         if not is_slice:             # <<<<<<<<<<<<<<
- *             if new_ndim == 0:
- *                 dst.data = (<char **> dst.data)[0] + suboffset
- */
-      goto __pyx_L25;
-    }
-
-    /* "View.MemoryView":902
- *                                      "must be indexed and not sliced", dim)
- *         else:
- *             suboffset_dim[0] = new_ndim             # <<<<<<<<<<<<<<
- * 
- *     return 0
- */
-    /*else*/ {
-      (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim;
-    }
-    __pyx_L25:;
-
-    /* "View.MemoryView":894
- *         dst.suboffsets[suboffset_dim[0]] += start * stride
- * 
- *     if suboffset >= 0:             # <<<<<<<<<<<<<<
- *         if not is_slice:
- *             if new_ndim == 0:
- */
-  }
-
-  /* "View.MemoryView":904
- *             suboffset_dim[0] = new_ndim
- * 
- *     return 0             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_r = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":807
- * 
- * @cname('__pyx_memoryview_slice_memviewslice')
- * cdef int slice_memviewslice(             # <<<<<<<<<<<<<<
- *         __Pyx_memviewslice *dst,
- *         Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset,
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  {
-    #ifdef WITH_THREAD
-    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-    #endif
-    __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
-    #ifdef WITH_THREAD
-    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-    #endif
-  }
-  __pyx_r = -1;
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "View.MemoryView":910
- * 
- * @cname('__pyx_pybuffer_index')
- * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index,             # <<<<<<<<<<<<<<
- *                           Py_ssize_t dim) except NULL:
- *     cdef Py_ssize_t shape, stride, suboffset = -1
- */
-
-static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) {
-  Py_ssize_t __pyx_v_shape;
-  Py_ssize_t __pyx_v_stride;
-  Py_ssize_t __pyx_v_suboffset;
-  Py_ssize_t __pyx_v_itemsize;
-  char *__pyx_v_resultp;
-  char *__pyx_r;
-  __Pyx_RefNannyDeclarations
-  Py_ssize_t __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("pybuffer_index", 0);
-
-  /* "View.MemoryView":912
- * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index,
- *                           Py_ssize_t dim) except NULL:
- *     cdef Py_ssize_t shape, stride, suboffset = -1             # <<<<<<<<<<<<<<
- *     cdef Py_ssize_t itemsize = view.itemsize
- *     cdef char *resultp
- */
-  __pyx_v_suboffset = -1L;
-
-  /* "View.MemoryView":913
- *                           Py_ssize_t dim) except NULL:
- *     cdef Py_ssize_t shape, stride, suboffset = -1
- *     cdef Py_ssize_t itemsize = view.itemsize             # <<<<<<<<<<<<<<
- *     cdef char *resultp
- * 
- */
-  __pyx_t_1 = __pyx_v_view->itemsize;
-  __pyx_v_itemsize = __pyx_t_1;
-
-  /* "View.MemoryView":916
- *     cdef char *resultp
- * 
- *     if view.ndim == 0:             # <<<<<<<<<<<<<<
- *         shape = view.len / itemsize
- *         stride = itemsize
- */
-  __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":917
- * 
- *     if view.ndim == 0:
- *         shape = view.len / itemsize             # <<<<<<<<<<<<<<
- *         stride = itemsize
- *     else:
- */
-    if (unlikely(__pyx_v_itemsize == 0)) {
-      PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
-      __PYX_ERR(1, 917, __pyx_L1_error)
-    }
-    else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1)  && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) {
-      PyErr_SetString(PyExc_OverflowError, "value too large to perform division");
-      __PYX_ERR(1, 917, __pyx_L1_error)
-    }
-    __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize);
-
-    /* "View.MemoryView":918
- *     if view.ndim == 0:
- *         shape = view.len / itemsize
- *         stride = itemsize             # <<<<<<<<<<<<<<
- *     else:
- *         shape = view.shape[dim]
- */
-    __pyx_v_stride = __pyx_v_itemsize;
-
-    /* "View.MemoryView":916
- *     cdef char *resultp
- * 
- *     if view.ndim == 0:             # <<<<<<<<<<<<<<
- *         shape = view.len / itemsize
- *         stride = itemsize
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":920
- *         stride = itemsize
- *     else:
- *         shape = view.shape[dim]             # <<<<<<<<<<<<<<
- *         stride = view.strides[dim]
- *         if view.suboffsets != NULL:
- */
-  /*else*/ {
-    __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]);
-
-    /* "View.MemoryView":921
- *     else:
- *         shape = view.shape[dim]
- *         stride = view.strides[dim]             # <<<<<<<<<<<<<<
- *         if view.suboffsets != NULL:
- *             suboffset = view.suboffsets[dim]
- */
-    __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]);
-
-    /* "View.MemoryView":922
- *         shape = view.shape[dim]
- *         stride = view.strides[dim]
- *         if view.suboffsets != NULL:             # <<<<<<<<<<<<<<
- *             suboffset = view.suboffsets[dim]
- * 
- */
-    __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":923
- *         stride = view.strides[dim]
- *         if view.suboffsets != NULL:
- *             suboffset = view.suboffsets[dim]             # <<<<<<<<<<<<<<
- * 
- *     if index < 0:
- */
-      __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]);
-
-      /* "View.MemoryView":922
- *         shape = view.shape[dim]
- *         stride = view.strides[dim]
- *         if view.suboffsets != NULL:             # <<<<<<<<<<<<<<
- *             suboffset = view.suboffsets[dim]
- * 
- */
-    }
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":925
- *             suboffset = view.suboffsets[dim]
- * 
- *     if index < 0:             # <<<<<<<<<<<<<<
- *         index += view.shape[dim]
- *         if index < 0:
- */
-  __pyx_t_2 = ((__pyx_v_index < 0) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":926
- * 
- *     if index < 0:
- *         index += view.shape[dim]             # <<<<<<<<<<<<<<
- *         if index < 0:
- *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
- */
-    __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim]));
-
-    /* "View.MemoryView":927
- *     if index < 0:
- *         index += view.shape[dim]
- *         if index < 0:             # <<<<<<<<<<<<<<
- *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
- * 
- */
-    __pyx_t_2 = ((__pyx_v_index < 0) != 0);
-    if (unlikely(__pyx_t_2)) {
-
-      /* "View.MemoryView":928
- *         index += view.shape[dim]
- *         if index < 0:
- *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)             # <<<<<<<<<<<<<<
- * 
- *     if index >= shape:
- */
-      __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 928, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 928, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 928, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __PYX_ERR(1, 928, __pyx_L1_error)
-
-      /* "View.MemoryView":927
- *     if index < 0:
- *         index += view.shape[dim]
- *         if index < 0:             # <<<<<<<<<<<<<<
- *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
- * 
- */
-    }
-
-    /* "View.MemoryView":925
- *             suboffset = view.suboffsets[dim]
- * 
- *     if index < 0:             # <<<<<<<<<<<<<<
- *         index += view.shape[dim]
- *         if index < 0:
- */
-  }
-
-  /* "View.MemoryView":930
- *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
- * 
- *     if index >= shape:             # <<<<<<<<<<<<<<
- *         raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
- * 
- */
-  __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0);
-  if (unlikely(__pyx_t_2)) {
-
-    /* "View.MemoryView":931
- * 
- *     if index >= shape:
- *         raise IndexError("Out of bounds on buffer access (axis %d)" % dim)             # <<<<<<<<<<<<<<
- * 
- *     resultp = bufp + index * stride
- */
-    __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 931, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 931, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 931, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(1, 931, __pyx_L1_error)
-
-    /* "View.MemoryView":930
- *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
- * 
- *     if index >= shape:             # <<<<<<<<<<<<<<
- *         raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
- * 
- */
-  }
-
-  /* "View.MemoryView":933
- *         raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
- * 
- *     resultp = bufp + index * stride             # <<<<<<<<<<<<<<
- *     if suboffset >= 0:
- *         resultp = (<char **> resultp)[0] + suboffset
- */
-  __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride));
-
-  /* "View.MemoryView":934
- * 
- *     resultp = bufp + index * stride
- *     if suboffset >= 0:             # <<<<<<<<<<<<<<
- *         resultp = (<char **> resultp)[0] + suboffset
- * 
- */
-  __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":935
- *     resultp = bufp + index * stride
- *     if suboffset >= 0:
- *         resultp = (<char **> resultp)[0] + suboffset             # <<<<<<<<<<<<<<
- * 
- *     return resultp
- */
-    __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset);
-
-    /* "View.MemoryView":934
- * 
- *     resultp = bufp + index * stride
- *     if suboffset >= 0:             # <<<<<<<<<<<<<<
- *         resultp = (<char **> resultp)[0] + suboffset
- * 
- */
-  }
-
-  /* "View.MemoryView":937
- *         resultp = (<char **> resultp)[0] + suboffset
- * 
- *     return resultp             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_r = __pyx_v_resultp;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":910
- * 
- * @cname('__pyx_pybuffer_index')
- * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index,             # <<<<<<<<<<<<<<
- *                           Py_ssize_t dim) except NULL:
- *     cdef Py_ssize_t shape, stride, suboffset = -1
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":943
- * 
- * @cname('__pyx_memslice_transpose')
- * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0:             # <<<<<<<<<<<<<<
- *     cdef int ndim = memslice.memview.view.ndim
- * 
- */
-
-static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) {
-  int __pyx_v_ndim;
-  Py_ssize_t *__pyx_v_shape;
-  Py_ssize_t *__pyx_v_strides;
-  int __pyx_v_i;
-  int __pyx_v_j;
-  int __pyx_r;
-  int __pyx_t_1;
-  Py_ssize_t *__pyx_t_2;
-  long __pyx_t_3;
-  long __pyx_t_4;
-  Py_ssize_t __pyx_t_5;
-  Py_ssize_t __pyx_t_6;
-  int __pyx_t_7;
-  int __pyx_t_8;
-  int __pyx_t_9;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-
-  /* "View.MemoryView":944
- * @cname('__pyx_memslice_transpose')
- * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0:
- *     cdef int ndim = memslice.memview.view.ndim             # <<<<<<<<<<<<<<
- * 
- *     cdef Py_ssize_t *shape = memslice.shape
- */
-  __pyx_t_1 = __pyx_v_memslice->memview->view.ndim;
-  __pyx_v_ndim = __pyx_t_1;
-
-  /* "View.MemoryView":946
- *     cdef int ndim = memslice.memview.view.ndim
- * 
- *     cdef Py_ssize_t *shape = memslice.shape             # <<<<<<<<<<<<<<
- *     cdef Py_ssize_t *strides = memslice.strides
- * 
- */
-  __pyx_t_2 = __pyx_v_memslice->shape;
-  __pyx_v_shape = __pyx_t_2;
-
-  /* "View.MemoryView":947
- * 
- *     cdef Py_ssize_t *shape = memslice.shape
- *     cdef Py_ssize_t *strides = memslice.strides             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_2 = __pyx_v_memslice->strides;
-  __pyx_v_strides = __pyx_t_2;
-
-  /* "View.MemoryView":951
- * 
- *     cdef int i, j
- *     for i in range(ndim / 2):             # <<<<<<<<<<<<<<
- *         j = ndim - 1 - i
- *         strides[i], strides[j] = strides[j], strides[i]
- */
-  __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2);
-  __pyx_t_4 = __pyx_t_3;
-  for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) {
-    __pyx_v_i = __pyx_t_1;
-
-    /* "View.MemoryView":952
- *     cdef int i, j
- *     for i in range(ndim / 2):
- *         j = ndim - 1 - i             # <<<<<<<<<<<<<<
- *         strides[i], strides[j] = strides[j], strides[i]
- *         shape[i], shape[j] = shape[j], shape[i]
- */
-    __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i);
-
-    /* "View.MemoryView":953
- *     for i in range(ndim / 2):
- *         j = ndim - 1 - i
- *         strides[i], strides[j] = strides[j], strides[i]             # <<<<<<<<<<<<<<
- *         shape[i], shape[j] = shape[j], shape[i]
- * 
- */
-    __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]);
-    __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]);
-    (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5;
-    (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6;
-
-    /* "View.MemoryView":954
- *         j = ndim - 1 - i
- *         strides[i], strides[j] = strides[j], strides[i]
- *         shape[i], shape[j] = shape[j], shape[i]             # <<<<<<<<<<<<<<
- * 
- *         if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:
- */
-    __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]);
-    __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]);
-    (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6;
-    (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5;
-
-    /* "View.MemoryView":956
- *         shape[i], shape[j] = shape[j], shape[i]
- * 
- *         if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:             # <<<<<<<<<<<<<<
- *             _err(ValueError, "Cannot transpose memoryview with indirect dimensions")
- * 
- */
-    __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0);
-    if (!__pyx_t_8) {
-    } else {
-      __pyx_t_7 = __pyx_t_8;
-      goto __pyx_L6_bool_binop_done;
-    }
-    __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0);
-    __pyx_t_7 = __pyx_t_8;
-    __pyx_L6_bool_binop_done:;
-    if (__pyx_t_7) {
-
-      /* "View.MemoryView":957
- * 
- *         if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:
- *             _err(ValueError, "Cannot transpose memoryview with indirect dimensions")             # <<<<<<<<<<<<<<
- * 
- *     return 1
- */
-      __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 957, __pyx_L1_error)
-
-      /* "View.MemoryView":956
- *         shape[i], shape[j] = shape[j], shape[i]
- * 
- *         if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:             # <<<<<<<<<<<<<<
- *             _err(ValueError, "Cannot transpose memoryview with indirect dimensions")
- * 
- */
-    }
-  }
-
-  /* "View.MemoryView":959
- *             _err(ValueError, "Cannot transpose memoryview with indirect dimensions")
- * 
- *     return 1             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_r = 1;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":943
- * 
- * @cname('__pyx_memslice_transpose')
- * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0:             # <<<<<<<<<<<<<<
- *     cdef int ndim = memslice.memview.view.ndim
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  {
-    #ifdef WITH_THREAD
-    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-    #endif
-    __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
-    #ifdef WITH_THREAD
-    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-    #endif
-  }
-  __pyx_r = 0;
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "View.MemoryView":976
- *     cdef int (*to_dtype_func)(char *, object) except 0
- * 
- *     def __dealloc__(self):             # <<<<<<<<<<<<<<
- *         __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
- * 
- */
-
-/* Python wrapper */
-static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/
-static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
-  __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
-
-  /* "View.MemoryView":977
- * 
- *     def __dealloc__(self):
- *         __PYX_XDEC_MEMVIEW(&self.from_slice, 1)             # <<<<<<<<<<<<<<
- * 
- *     cdef convert_item_to_object(self, char *itemp):
- */
-  __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1);
-
-  /* "View.MemoryView":976
- *     cdef int (*to_dtype_func)(char *, object) except 0
- * 
- *     def __dealloc__(self):             # <<<<<<<<<<<<<<
- *         __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
- * 
- */
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-/* "View.MemoryView":979
- *         __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
- * 
- *     cdef convert_item_to_object(self, char *itemp):             # <<<<<<<<<<<<<<
- *         if self.to_object_func != NULL:
- *             return self.to_object_func(itemp)
- */
-
-static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("convert_item_to_object", 0);
-
-  /* "View.MemoryView":980
- * 
- *     cdef convert_item_to_object(self, char *itemp):
- *         if self.to_object_func != NULL:             # <<<<<<<<<<<<<<
- *             return self.to_object_func(itemp)
- *         else:
- */
-  __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":981
- *     cdef convert_item_to_object(self, char *itemp):
- *         if self.to_object_func != NULL:
- *             return self.to_object_func(itemp)             # <<<<<<<<<<<<<<
- *         else:
- *             return memoryview.convert_item_to_object(self, itemp)
- */
-    __Pyx_XDECREF(__pyx_r);
-    __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 981, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_r = __pyx_t_2;
-    __pyx_t_2 = 0;
-    goto __pyx_L0;
-
-    /* "View.MemoryView":980
- * 
- *     cdef convert_item_to_object(self, char *itemp):
- *         if self.to_object_func != NULL:             # <<<<<<<<<<<<<<
- *             return self.to_object_func(itemp)
- *         else:
- */
-  }
-
-  /* "View.MemoryView":983
- *             return self.to_object_func(itemp)
- *         else:
- *             return memoryview.convert_item_to_object(self, itemp)             # <<<<<<<<<<<<<<
- * 
- *     cdef assign_item_from_object(self, char *itemp, object value):
- */
-  /*else*/ {
-    __Pyx_XDECREF(__pyx_r);
-    __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 983, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_r = __pyx_t_2;
-    __pyx_t_2 = 0;
-    goto __pyx_L0;
-  }
-
-  /* "View.MemoryView":979
- *         __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
- * 
- *     cdef convert_item_to_object(self, char *itemp):             # <<<<<<<<<<<<<<
- *         if self.to_object_func != NULL:
- *             return self.to_object_func(itemp)
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":985
- *             return memoryview.convert_item_to_object(self, itemp)
- * 
- *     cdef assign_item_from_object(self, char *itemp, object value):             # <<<<<<<<<<<<<<
- *         if self.to_dtype_func != NULL:
- *             self.to_dtype_func(itemp, value)
- */
-
-static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("assign_item_from_object", 0);
-
-  /* "View.MemoryView":986
- * 
- *     cdef assign_item_from_object(self, char *itemp, object value):
- *         if self.to_dtype_func != NULL:             # <<<<<<<<<<<<<<
- *             self.to_dtype_func(itemp, value)
- *         else:
- */
-  __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":987
- *     cdef assign_item_from_object(self, char *itemp, object value):
- *         if self.to_dtype_func != NULL:
- *             self.to_dtype_func(itemp, value)             # <<<<<<<<<<<<<<
- *         else:
- *             memoryview.assign_item_from_object(self, itemp, value)
- */
-    __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 987, __pyx_L1_error)
-
-    /* "View.MemoryView":986
- * 
- *     cdef assign_item_from_object(self, char *itemp, object value):
- *         if self.to_dtype_func != NULL:             # <<<<<<<<<<<<<<
- *             self.to_dtype_func(itemp, value)
- *         else:
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":989
- *             self.to_dtype_func(itemp, value)
- *         else:
- *             memoryview.assign_item_from_object(self, itemp, value)             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  /*else*/ {
-    __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 989, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":985
- *             return memoryview.convert_item_to_object(self, itemp)
- * 
- *     cdef assign_item_from_object(self, char *itemp, object value):             # <<<<<<<<<<<<<<
- *         if self.to_dtype_func != NULL:
- *             self.to_dtype_func(itemp, value)
- */
-
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":992
- * 
- *     @property
- *     def base(self):             # <<<<<<<<<<<<<<
- *         return self.from_object
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "View.MemoryView":993
- *     @property
- *     def base(self):
- *         return self.from_object             # <<<<<<<<<<<<<<
- * 
- *     __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_self->from_object);
-  __pyx_r = __pyx_v_self->from_object;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":992
- * 
- *     @property
- *     def base(self):             # <<<<<<<<<<<<<<
- *         return self.from_object
- * 
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
-
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(1, 2, __pyx_L1_error)
-
-  /* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(1, 4, __pyx_L1_error)
-
-  /* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":999
- * 
- * @cname('__pyx_memoryview_fromslice')
- * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice,             # <<<<<<<<<<<<<<
- *                           int ndim,
- *                           object (*to_object_func)(char *),
- */
-
-static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) {
-  struct __pyx_memoryviewslice_obj *__pyx_v_result = 0;
-  Py_ssize_t __pyx_v_suboffset;
-  PyObject *__pyx_v_length = NULL;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_TypeInfo *__pyx_t_4;
-  Py_buffer __pyx_t_5;
-  Py_ssize_t *__pyx_t_6;
-  Py_ssize_t *__pyx_t_7;
-  Py_ssize_t *__pyx_t_8;
-  Py_ssize_t __pyx_t_9;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("memoryview_fromslice", 0);
-
-  /* "View.MemoryView":1007
- *     cdef _memoryviewslice result
- * 
- *     if <PyObject *> memviewslice.memview == Py_None:             # <<<<<<<<<<<<<<
- *         return None
- * 
- */
-  __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":1008
- * 
- *     if <PyObject *> memviewslice.memview == Py_None:
- *         return None             # <<<<<<<<<<<<<<
- * 
- * 
- */
-    __Pyx_XDECREF(__pyx_r);
-    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-    goto __pyx_L0;
-
-    /* "View.MemoryView":1007
- *     cdef _memoryviewslice result
- * 
- *     if <PyObject *> memviewslice.memview == Py_None:             # <<<<<<<<<<<<<<
- *         return None
- * 
- */
-  }
-
-  /* "View.MemoryView":1013
- * 
- * 
- *     result = _memoryviewslice(None, 0, dtype_is_object)             # <<<<<<<<<<<<<<
- * 
- *     result.from_slice = memviewslice
- */
-  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1013, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_INCREF(Py_None);
-  __Pyx_GIVEREF(Py_None);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None);
-  __Pyx_INCREF(__pyx_int_0);
-  __Pyx_GIVEREF(__pyx_int_0);
-  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2);
-  __pyx_t_2 = 0;
-
-  /* "View.MemoryView":1015
- *     result = _memoryviewslice(None, 0, dtype_is_object)
- * 
- *     result.from_slice = memviewslice             # <<<<<<<<<<<<<<
- *     __PYX_INC_MEMVIEW(&memviewslice, 1)
- * 
- */
-  __pyx_v_result->from_slice = __pyx_v_memviewslice;
-
-  /* "View.MemoryView":1016
- * 
- *     result.from_slice = memviewslice
- *     __PYX_INC_MEMVIEW(&memviewslice, 1)             # <<<<<<<<<<<<<<
- * 
- *     result.from_object = (<memoryview> memviewslice.memview).base
- */
-  __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1);
-
-  /* "View.MemoryView":1018
- *     __PYX_INC_MEMVIEW(&memviewslice, 1)
- * 
- *     result.from_object = (<memoryview> memviewslice.memview).base             # <<<<<<<<<<<<<<
- *     result.typeinfo = memviewslice.memview.typeinfo
- * 
- */
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1018, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_2);
-  __Pyx_GOTREF(__pyx_v_result->from_object);
-  __Pyx_DECREF(__pyx_v_result->from_object);
-  __pyx_v_result->from_object = __pyx_t_2;
-  __pyx_t_2 = 0;
-
-  /* "View.MemoryView":1019
- * 
- *     result.from_object = (<memoryview> memviewslice.memview).base
- *     result.typeinfo = memviewslice.memview.typeinfo             # <<<<<<<<<<<<<<
- * 
- *     result.view = memviewslice.memview.view
- */
-  __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo;
-  __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4;
-
-  /* "View.MemoryView":1021
- *     result.typeinfo = memviewslice.memview.typeinfo
- * 
- *     result.view = memviewslice.memview.view             # <<<<<<<<<<<<<<
- *     result.view.buf = <void *> memviewslice.data
- *     result.view.ndim = ndim
- */
-  __pyx_t_5 = __pyx_v_memviewslice.memview->view;
-  __pyx_v_result->__pyx_base.view = __pyx_t_5;
-
-  /* "View.MemoryView":1022
- * 
- *     result.view = memviewslice.memview.view
- *     result.view.buf = <void *> memviewslice.data             # <<<<<<<<<<<<<<
- *     result.view.ndim = ndim
- *     (<__pyx_buffer *> &result.view).obj = Py_None
- */
-  __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data);
-
-  /* "View.MemoryView":1023
- *     result.view = memviewslice.memview.view
- *     result.view.buf = <void *> memviewslice.data
- *     result.view.ndim = ndim             # <<<<<<<<<<<<<<
- *     (<__pyx_buffer *> &result.view).obj = Py_None
- *     Py_INCREF(Py_None)
- */
-  __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim;
-
-  /* "View.MemoryView":1024
- *     result.view.buf = <void *> memviewslice.data
- *     result.view.ndim = ndim
- *     (<__pyx_buffer *> &result.view).obj = Py_None             # <<<<<<<<<<<<<<
- *     Py_INCREF(Py_None)
- * 
- */
-  ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None;
-
-  /* "View.MemoryView":1025
- *     result.view.ndim = ndim
- *     (<__pyx_buffer *> &result.view).obj = Py_None
- *     Py_INCREF(Py_None)             # <<<<<<<<<<<<<<
- * 
- *     if (<memoryview>memviewslice.memview).flags & PyBUF_WRITABLE:
- */
-  Py_INCREF(Py_None);
-
-  /* "View.MemoryView":1027
- *     Py_INCREF(Py_None)
- * 
- *     if (<memoryview>memviewslice.memview).flags & PyBUF_WRITABLE:             # <<<<<<<<<<<<<<
- *         result.flags = PyBUF_RECORDS
- *     else:
- */
-  __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":1028
- * 
- *     if (<memoryview>memviewslice.memview).flags & PyBUF_WRITABLE:
- *         result.flags = PyBUF_RECORDS             # <<<<<<<<<<<<<<
- *     else:
- *         result.flags = PyBUF_RECORDS_RO
- */
-    __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS;
-
-    /* "View.MemoryView":1027
- *     Py_INCREF(Py_None)
- * 
- *     if (<memoryview>memviewslice.memview).flags & PyBUF_WRITABLE:             # <<<<<<<<<<<<<<
- *         result.flags = PyBUF_RECORDS
- *     else:
- */
-    goto __pyx_L4;
-  }
-
-  /* "View.MemoryView":1030
- *         result.flags = PyBUF_RECORDS
- *     else:
- *         result.flags = PyBUF_RECORDS_RO             # <<<<<<<<<<<<<<
- * 
- *     result.view.shape = <Py_ssize_t *> result.from_slice.shape
- */
-  /*else*/ {
-    __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO;
-  }
-  __pyx_L4:;
-
-  /* "View.MemoryView":1032
- *         result.flags = PyBUF_RECORDS_RO
- * 
- *     result.view.shape = <Py_ssize_t *> result.from_slice.shape             # <<<<<<<<<<<<<<
- *     result.view.strides = <Py_ssize_t *> result.from_slice.strides
- * 
- */
-  __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape);
-
-  /* "View.MemoryView":1033
- * 
- *     result.view.shape = <Py_ssize_t *> result.from_slice.shape
- *     result.view.strides = <Py_ssize_t *> result.from_slice.strides             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides);
-
-  /* "View.MemoryView":1036
- * 
- * 
- *     result.view.suboffsets = NULL             # <<<<<<<<<<<<<<
- *     for suboffset in result.from_slice.suboffsets[:ndim]:
- *         if suboffset >= 0:
- */
-  __pyx_v_result->__pyx_base.view.suboffsets = NULL;
-
-  /* "View.MemoryView":1037
- * 
- *     result.view.suboffsets = NULL
- *     for suboffset in result.from_slice.suboffsets[:ndim]:             # <<<<<<<<<<<<<<
- *         if suboffset >= 0:
- *             result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets
- */
-  __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim);
-  for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) {
-    __pyx_t_6 = __pyx_t_8;
-    __pyx_v_suboffset = (__pyx_t_6[0]);
-
-    /* "View.MemoryView":1038
- *     result.view.suboffsets = NULL
- *     for suboffset in result.from_slice.suboffsets[:ndim]:
- *         if suboffset >= 0:             # <<<<<<<<<<<<<<
- *             result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets
- *             break
- */
-    __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0);
-    if (__pyx_t_1) {
-
-      /* "View.MemoryView":1039
- *     for suboffset in result.from_slice.suboffsets[:ndim]:
- *         if suboffset >= 0:
- *             result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets             # <<<<<<<<<<<<<<
- *             break
- * 
- */
-      __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets);
-
-      /* "View.MemoryView":1040
- *         if suboffset >= 0:
- *             result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets
- *             break             # <<<<<<<<<<<<<<
- * 
- *     result.view.len = result.view.itemsize
- */
-      goto __pyx_L6_break;
-
-      /* "View.MemoryView":1038
- *     result.view.suboffsets = NULL
- *     for suboffset in result.from_slice.suboffsets[:ndim]:
- *         if suboffset >= 0:             # <<<<<<<<<<<<<<
- *             result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets
- *             break
- */
-    }
-  }
-  __pyx_L6_break:;
-
-  /* "View.MemoryView":1042
- *             break
- * 
- *     result.view.len = result.view.itemsize             # <<<<<<<<<<<<<<
- *     for length in result.view.shape[:ndim]:
- *         result.view.len *= length
- */
-  __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize;
-  __pyx_v_result->__pyx_base.view.len = __pyx_t_9;
-
-  /* "View.MemoryView":1043
- * 
- *     result.view.len = result.view.itemsize
- *     for length in result.view.shape[:ndim]:             # <<<<<<<<<<<<<<
- *         result.view.len *= length
- * 
- */
-  __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim);
-  for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) {
-    __pyx_t_6 = __pyx_t_8;
-    __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1043, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2);
-    __pyx_t_2 = 0;
-
-    /* "View.MemoryView":1044
- *     result.view.len = result.view.itemsize
- *     for length in result.view.shape[:ndim]:
- *         result.view.len *= length             # <<<<<<<<<<<<<<
- * 
- *     result.to_object_func = to_object_func
- */
-    __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1044, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1044, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1044, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_v_result->__pyx_base.view.len = __pyx_t_9;
-  }
-
-  /* "View.MemoryView":1046
- *         result.view.len *= length
- * 
- *     result.to_object_func = to_object_func             # <<<<<<<<<<<<<<
- *     result.to_dtype_func = to_dtype_func
- * 
- */
-  __pyx_v_result->to_object_func = __pyx_v_to_object_func;
-
-  /* "View.MemoryView":1047
- * 
- *     result.to_object_func = to_object_func
- *     result.to_dtype_func = to_dtype_func             # <<<<<<<<<<<<<<
- * 
- *     return result
- */
-  __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func;
-
-  /* "View.MemoryView":1049
- *     result.to_dtype_func = to_dtype_func
- * 
- *     return result             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_memoryview_get_slice_from_memoryview')
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_result));
-  __pyx_r = ((PyObject *)__pyx_v_result);
-  goto __pyx_L0;
-
-  /* "View.MemoryView":999
- * 
- * @cname('__pyx_memoryview_fromslice')
- * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice,             # <<<<<<<<<<<<<<
- *                           int ndim,
- *                           object (*to_object_func)(char *),
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_result);
-  __Pyx_XDECREF(__pyx_v_length);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1052
- * 
- * @cname('__pyx_memoryview_get_slice_from_memoryview')
- * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview,             # <<<<<<<<<<<<<<
- *                                                    __Pyx_memviewslice *mslice) except NULL:
- *     cdef _memoryviewslice obj
- */
-
-static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) {
-  struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0;
-  __Pyx_memviewslice *__pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("get_slice_from_memview", 0);
-
-  /* "View.MemoryView":1055
- *                                                    __Pyx_memviewslice *mslice) except NULL:
- *     cdef _memoryviewslice obj
- *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
- *         obj = memview
- *         return &obj.from_slice
- */
-  __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); 
-  __pyx_t_2 = (__pyx_t_1 != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":1056
- *     cdef _memoryviewslice obj
- *     if isinstance(memview, _memoryviewslice):
- *         obj = memview             # <<<<<<<<<<<<<<
- *         return &obj.from_slice
- *     else:
- */
-    if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1056, __pyx_L1_error)
-    __pyx_t_3 = ((PyObject *)__pyx_v_memview);
-    __Pyx_INCREF(__pyx_t_3);
-    __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3);
-    __pyx_t_3 = 0;
-
-    /* "View.MemoryView":1057
- *     if isinstance(memview, _memoryviewslice):
- *         obj = memview
- *         return &obj.from_slice             # <<<<<<<<<<<<<<
- *     else:
- *         slice_copy(memview, mslice)
- */
-    __pyx_r = (&__pyx_v_obj->from_slice);
-    goto __pyx_L0;
-
-    /* "View.MemoryView":1055
- *                                                    __Pyx_memviewslice *mslice) except NULL:
- *     cdef _memoryviewslice obj
- *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
- *         obj = memview
- *         return &obj.from_slice
- */
-  }
-
-  /* "View.MemoryView":1059
- *         return &obj.from_slice
- *     else:
- *         slice_copy(memview, mslice)             # <<<<<<<<<<<<<<
- *         return mslice
- * 
- */
-  /*else*/ {
-    __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice);
-
-    /* "View.MemoryView":1060
- *     else:
- *         slice_copy(memview, mslice)
- *         return mslice             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_memoryview_slice_copy')
- */
-    __pyx_r = __pyx_v_mslice;
-    goto __pyx_L0;
-  }
-
-  /* "View.MemoryView":1052
- * 
- * @cname('__pyx_memoryview_get_slice_from_memoryview')
- * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview,             # <<<<<<<<<<<<<<
- *                                                    __Pyx_memviewslice *mslice) except NULL:
- *     cdef _memoryviewslice obj
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_obj);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1063
- * 
- * @cname('__pyx_memoryview_slice_copy')
- * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst):             # <<<<<<<<<<<<<<
- *     cdef int dim
- *     cdef (Py_ssize_t*) shape, strides, suboffsets
- */
-
-static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) {
-  int __pyx_v_dim;
-  Py_ssize_t *__pyx_v_shape;
-  Py_ssize_t *__pyx_v_strides;
-  Py_ssize_t *__pyx_v_suboffsets;
-  __Pyx_RefNannyDeclarations
-  Py_ssize_t *__pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  int __pyx_t_4;
-  Py_ssize_t __pyx_t_5;
-  __Pyx_RefNannySetupContext("slice_copy", 0);
-
-  /* "View.MemoryView":1067
- *     cdef (Py_ssize_t*) shape, strides, suboffsets
- * 
- *     shape = memview.view.shape             # <<<<<<<<<<<<<<
- *     strides = memview.view.strides
- *     suboffsets = memview.view.suboffsets
- */
-  __pyx_t_1 = __pyx_v_memview->view.shape;
-  __pyx_v_shape = __pyx_t_1;
-
-  /* "View.MemoryView":1068
- * 
- *     shape = memview.view.shape
- *     strides = memview.view.strides             # <<<<<<<<<<<<<<
- *     suboffsets = memview.view.suboffsets
- * 
- */
-  __pyx_t_1 = __pyx_v_memview->view.strides;
-  __pyx_v_strides = __pyx_t_1;
-
-  /* "View.MemoryView":1069
- *     shape = memview.view.shape
- *     strides = memview.view.strides
- *     suboffsets = memview.view.suboffsets             # <<<<<<<<<<<<<<
- * 
- *     dst.memview = <__pyx_memoryview *> memview
- */
-  __pyx_t_1 = __pyx_v_memview->view.suboffsets;
-  __pyx_v_suboffsets = __pyx_t_1;
-
-  /* "View.MemoryView":1071
- *     suboffsets = memview.view.suboffsets
- * 
- *     dst.memview = <__pyx_memoryview *> memview             # <<<<<<<<<<<<<<
- *     dst.data = <char *> memview.view.buf
- * 
- */
-  __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview);
-
-  /* "View.MemoryView":1072
- * 
- *     dst.memview = <__pyx_memoryview *> memview
- *     dst.data = <char *> memview.view.buf             # <<<<<<<<<<<<<<
- * 
- *     for dim in range(memview.view.ndim):
- */
-  __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf);
-
-  /* "View.MemoryView":1074
- *     dst.data = <char *> memview.view.buf
- * 
- *     for dim in range(memview.view.ndim):             # <<<<<<<<<<<<<<
- *         dst.shape[dim] = shape[dim]
- *         dst.strides[dim] = strides[dim]
- */
-  __pyx_t_2 = __pyx_v_memview->view.ndim;
-  __pyx_t_3 = __pyx_t_2;
-  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
-    __pyx_v_dim = __pyx_t_4;
-
-    /* "View.MemoryView":1075
- * 
- *     for dim in range(memview.view.ndim):
- *         dst.shape[dim] = shape[dim]             # <<<<<<<<<<<<<<
- *         dst.strides[dim] = strides[dim]
- *         dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1
- */
-    (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]);
-
-    /* "View.MemoryView":1076
- *     for dim in range(memview.view.ndim):
- *         dst.shape[dim] = shape[dim]
- *         dst.strides[dim] = strides[dim]             # <<<<<<<<<<<<<<
- *         dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1
- * 
- */
-    (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]);
-
-    /* "View.MemoryView":1077
- *         dst.shape[dim] = shape[dim]
- *         dst.strides[dim] = strides[dim]
- *         dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_memoryview_copy_object')
- */
-    if ((__pyx_v_suboffsets != 0)) {
-      __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]);
-    } else {
-      __pyx_t_5 = -1L;
-    }
-    (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5;
-  }
-
-  /* "View.MemoryView":1063
- * 
- * @cname('__pyx_memoryview_slice_copy')
- * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst):             # <<<<<<<<<<<<<<
- *     cdef int dim
- *     cdef (Py_ssize_t*) shape, strides, suboffsets
- */
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-/* "View.MemoryView":1080
- * 
- * @cname('__pyx_memoryview_copy_object')
- * cdef memoryview_copy(memoryview memview):             # <<<<<<<<<<<<<<
- *     "Create a new memoryview object"
- *     cdef __Pyx_memviewslice memviewslice
- */
-
-static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) {
-  __Pyx_memviewslice __pyx_v_memviewslice;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("memoryview_copy", 0);
-
-  /* "View.MemoryView":1083
- *     "Create a new memoryview object"
- *     cdef __Pyx_memviewslice memviewslice
- *     slice_copy(memview, &memviewslice)             # <<<<<<<<<<<<<<
- *     return memoryview_copy_from_slice(memview, &memviewslice)
- * 
- */
-  __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice));
-
-  /* "View.MemoryView":1084
- *     cdef __Pyx_memviewslice memviewslice
- *     slice_copy(memview, &memviewslice)
- *     return memoryview_copy_from_slice(memview, &memviewslice)             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_memoryview_copy_object_from_slice')
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1084, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":1080
- * 
- * @cname('__pyx_memoryview_copy_object')
- * cdef memoryview_copy(memoryview memview):             # <<<<<<<<<<<<<<
- *     "Create a new memoryview object"
- *     cdef __Pyx_memviewslice memviewslice
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1087
- * 
- * @cname('__pyx_memoryview_copy_object_from_slice')
- * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice):             # <<<<<<<<<<<<<<
- *     """
- *     Create a new memoryview object from a given memoryview object and slice.
- */
-
-static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) {
-  PyObject *(*__pyx_v_to_object_func)(char *);
-  int (*__pyx_v_to_dtype_func)(char *, PyObject *);
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *(*__pyx_t_3)(char *);
-  int (*__pyx_t_4)(char *, PyObject *);
-  PyObject *__pyx_t_5 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0);
-
-  /* "View.MemoryView":1094
- *     cdef int (*to_dtype_func)(char *, object) except 0
- * 
- *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
- *         to_object_func = (<_memoryviewslice> memview).to_object_func
- *         to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
- */
-  __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); 
-  __pyx_t_2 = (__pyx_t_1 != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":1095
- * 
- *     if isinstance(memview, _memoryviewslice):
- *         to_object_func = (<_memoryviewslice> memview).to_object_func             # <<<<<<<<<<<<<<
- *         to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
- *     else:
- */
-    __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func;
-    __pyx_v_to_object_func = __pyx_t_3;
-
-    /* "View.MemoryView":1096
- *     if isinstance(memview, _memoryviewslice):
- *         to_object_func = (<_memoryviewslice> memview).to_object_func
- *         to_dtype_func = (<_memoryviewslice> memview).to_dtype_func             # <<<<<<<<<<<<<<
- *     else:
- *         to_object_func = NULL
- */
-    __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func;
-    __pyx_v_to_dtype_func = __pyx_t_4;
-
-    /* "View.MemoryView":1094
- *     cdef int (*to_dtype_func)(char *, object) except 0
- * 
- *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
- *         to_object_func = (<_memoryviewslice> memview).to_object_func
- *         to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":1098
- *         to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
- *     else:
- *         to_object_func = NULL             # <<<<<<<<<<<<<<
- *         to_dtype_func = NULL
- * 
- */
-  /*else*/ {
-    __pyx_v_to_object_func = NULL;
-
-    /* "View.MemoryView":1099
- *     else:
- *         to_object_func = NULL
- *         to_dtype_func = NULL             # <<<<<<<<<<<<<<
- * 
- *     return memoryview_fromslice(memviewslice[0], memview.view.ndim,
- */
-    __pyx_v_to_dtype_func = NULL;
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":1101
- *         to_dtype_func = NULL
- * 
- *     return memoryview_fromslice(memviewslice[0], memview.view.ndim,             # <<<<<<<<<<<<<<
- *                                 to_object_func, to_dtype_func,
- *                                 memview.dtype_is_object)
- */
-  __Pyx_XDECREF(__pyx_r);
-
-  /* "View.MemoryView":1103
- *     return memoryview_fromslice(memviewslice[0], memview.view.ndim,
- *                                 to_object_func, to_dtype_func,
- *                                 memview.dtype_is_object)             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1101, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __pyx_r = __pyx_t_5;
-  __pyx_t_5 = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":1087
- * 
- * @cname('__pyx_memoryview_copy_object_from_slice')
- * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice):             # <<<<<<<<<<<<<<
- *     """
- *     Create a new memoryview object from a given memoryview object and slice.
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1109
- * 
- * 
- * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:             # <<<<<<<<<<<<<<
- *     if arg < 0:
- *         return -arg
- */
-
-static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) {
-  Py_ssize_t __pyx_r;
-  int __pyx_t_1;
-
-  /* "View.MemoryView":1110
- * 
- * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:
- *     if arg < 0:             # <<<<<<<<<<<<<<
- *         return -arg
- *     else:
- */
-  __pyx_t_1 = ((__pyx_v_arg < 0) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":1111
- * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:
- *     if arg < 0:
- *         return -arg             # <<<<<<<<<<<<<<
- *     else:
- *         return arg
- */
-    __pyx_r = (-__pyx_v_arg);
-    goto __pyx_L0;
-
-    /* "View.MemoryView":1110
- * 
- * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:
- *     if arg < 0:             # <<<<<<<<<<<<<<
- *         return -arg
- *     else:
- */
-  }
-
-  /* "View.MemoryView":1113
- *         return -arg
- *     else:
- *         return arg             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_get_best_slice_order')
- */
-  /*else*/ {
-    __pyx_r = __pyx_v_arg;
-    goto __pyx_L0;
-  }
-
-  /* "View.MemoryView":1109
- * 
- * 
- * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:             # <<<<<<<<<<<<<<
- *     if arg < 0:
- *         return -arg
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1116
- * 
- * @cname('__pyx_get_best_slice_order')
- * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil:             # <<<<<<<<<<<<<<
- *     """
- *     Figure out the best memory access order for a given slice.
- */
-
-static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) {
-  int __pyx_v_i;
-  Py_ssize_t __pyx_v_c_stride;
-  Py_ssize_t __pyx_v_f_stride;
-  char __pyx_r;
-  int __pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  int __pyx_t_4;
-
-  /* "View.MemoryView":1121
- *     """
- *     cdef int i
- *     cdef Py_ssize_t c_stride = 0             # <<<<<<<<<<<<<<
- *     cdef Py_ssize_t f_stride = 0
- * 
- */
-  __pyx_v_c_stride = 0;
-
-  /* "View.MemoryView":1122
- *     cdef int i
- *     cdef Py_ssize_t c_stride = 0
- *     cdef Py_ssize_t f_stride = 0             # <<<<<<<<<<<<<<
- * 
- *     for i in range(ndim - 1, -1, -1):
- */
-  __pyx_v_f_stride = 0;
-
-  /* "View.MemoryView":1124
- *     cdef Py_ssize_t f_stride = 0
- * 
- *     for i in range(ndim - 1, -1, -1):             # <<<<<<<<<<<<<<
- *         if mslice.shape[i] > 1:
- *             c_stride = mslice.strides[i]
- */
-  for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) {
-    __pyx_v_i = __pyx_t_1;
-
-    /* "View.MemoryView":1125
- * 
- *     for i in range(ndim - 1, -1, -1):
- *         if mslice.shape[i] > 1:             # <<<<<<<<<<<<<<
- *             c_stride = mslice.strides[i]
- *             break
- */
-    __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":1126
- *     for i in range(ndim - 1, -1, -1):
- *         if mslice.shape[i] > 1:
- *             c_stride = mslice.strides[i]             # <<<<<<<<<<<<<<
- *             break
- * 
- */
-      __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]);
-
-      /* "View.MemoryView":1127
- *         if mslice.shape[i] > 1:
- *             c_stride = mslice.strides[i]
- *             break             # <<<<<<<<<<<<<<
- * 
- *     for i in range(ndim):
- */
-      goto __pyx_L4_break;
-
-      /* "View.MemoryView":1125
- * 
- *     for i in range(ndim - 1, -1, -1):
- *         if mslice.shape[i] > 1:             # <<<<<<<<<<<<<<
- *             c_stride = mslice.strides[i]
- *             break
- */
-    }
-  }
-  __pyx_L4_break:;
-
-  /* "View.MemoryView":1129
- *             break
- * 
- *     for i in range(ndim):             # <<<<<<<<<<<<<<
- *         if mslice.shape[i] > 1:
- *             f_stride = mslice.strides[i]
- */
-  __pyx_t_1 = __pyx_v_ndim;
-  __pyx_t_3 = __pyx_t_1;
-  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
-    __pyx_v_i = __pyx_t_4;
-
-    /* "View.MemoryView":1130
- * 
- *     for i in range(ndim):
- *         if mslice.shape[i] > 1:             # <<<<<<<<<<<<<<
- *             f_stride = mslice.strides[i]
- *             break
- */
-    __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":1131
- *     for i in range(ndim):
- *         if mslice.shape[i] > 1:
- *             f_stride = mslice.strides[i]             # <<<<<<<<<<<<<<
- *             break
- * 
- */
-      __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]);
-
-      /* "View.MemoryView":1132
- *         if mslice.shape[i] > 1:
- *             f_stride = mslice.strides[i]
- *             break             # <<<<<<<<<<<<<<
- * 
- *     if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):
- */
-      goto __pyx_L7_break;
-
-      /* "View.MemoryView":1130
- * 
- *     for i in range(ndim):
- *         if mslice.shape[i] > 1:             # <<<<<<<<<<<<<<
- *             f_stride = mslice.strides[i]
- *             break
- */
-    }
-  }
-  __pyx_L7_break:;
-
-  /* "View.MemoryView":1134
- *             break
- * 
- *     if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):             # <<<<<<<<<<<<<<
- *         return 'C'
- *     else:
- */
-  __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":1135
- * 
- *     if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):
- *         return 'C'             # <<<<<<<<<<<<<<
- *     else:
- *         return 'F'
- */
-    __pyx_r = 'C';
-    goto __pyx_L0;
-
-    /* "View.MemoryView":1134
- *             break
- * 
- *     if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):             # <<<<<<<<<<<<<<
- *         return 'C'
- *     else:
- */
-  }
-
-  /* "View.MemoryView":1137
- *         return 'C'
- *     else:
- *         return 'F'             # <<<<<<<<<<<<<<
- * 
- * @cython.cdivision(True)
- */
-  /*else*/ {
-    __pyx_r = 'F';
-    goto __pyx_L0;
-  }
-
-  /* "View.MemoryView":1116
- * 
- * @cname('__pyx_get_best_slice_order')
- * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil:             # <<<<<<<<<<<<<<
- *     """
- *     Figure out the best memory access order for a given slice.
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1140
- * 
- * @cython.cdivision(True)
- * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides,             # <<<<<<<<<<<<<<
- *                                    char *dst_data, Py_ssize_t *dst_strides,
- *                                    Py_ssize_t *src_shape, Py_ssize_t *dst_shape,
- */
-
-static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) {
-  CYTHON_UNUSED Py_ssize_t __pyx_v_i;
-  CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent;
-  Py_ssize_t __pyx_v_dst_extent;
-  Py_ssize_t __pyx_v_src_stride;
-  Py_ssize_t __pyx_v_dst_stride;
-  int __pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  Py_ssize_t __pyx_t_4;
-  Py_ssize_t __pyx_t_5;
-  Py_ssize_t __pyx_t_6;
-
-  /* "View.MemoryView":1147
- * 
- *     cdef Py_ssize_t i
- *     cdef Py_ssize_t src_extent = src_shape[0]             # <<<<<<<<<<<<<<
- *     cdef Py_ssize_t dst_extent = dst_shape[0]
- *     cdef Py_ssize_t src_stride = src_strides[0]
- */
-  __pyx_v_src_extent = (__pyx_v_src_shape[0]);
-
-  /* "View.MemoryView":1148
- *     cdef Py_ssize_t i
- *     cdef Py_ssize_t src_extent = src_shape[0]
- *     cdef Py_ssize_t dst_extent = dst_shape[0]             # <<<<<<<<<<<<<<
- *     cdef Py_ssize_t src_stride = src_strides[0]
- *     cdef Py_ssize_t dst_stride = dst_strides[0]
- */
-  __pyx_v_dst_extent = (__pyx_v_dst_shape[0]);
-
-  /* "View.MemoryView":1149
- *     cdef Py_ssize_t src_extent = src_shape[0]
- *     cdef Py_ssize_t dst_extent = dst_shape[0]
- *     cdef Py_ssize_t src_stride = src_strides[0]             # <<<<<<<<<<<<<<
- *     cdef Py_ssize_t dst_stride = dst_strides[0]
- * 
- */
-  __pyx_v_src_stride = (__pyx_v_src_strides[0]);
-
-  /* "View.MemoryView":1150
- *     cdef Py_ssize_t dst_extent = dst_shape[0]
- *     cdef Py_ssize_t src_stride = src_strides[0]
- *     cdef Py_ssize_t dst_stride = dst_strides[0]             # <<<<<<<<<<<<<<
- * 
- *     if ndim == 1:
- */
-  __pyx_v_dst_stride = (__pyx_v_dst_strides[0]);
-
-  /* "View.MemoryView":1152
- *     cdef Py_ssize_t dst_stride = dst_strides[0]
- * 
- *     if ndim == 1:             # <<<<<<<<<<<<<<
- *        if (src_stride > 0 and dst_stride > 0 and
- *            <size_t> src_stride == itemsize == <size_t> dst_stride):
- */
-  __pyx_t_1 = ((__pyx_v_ndim == 1) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":1153
- * 
- *     if ndim == 1:
- *        if (src_stride > 0 and dst_stride > 0 and             # <<<<<<<<<<<<<<
- *            <size_t> src_stride == itemsize == <size_t> dst_stride):
- *            memcpy(dst_data, src_data, itemsize * dst_extent)
- */
-    __pyx_t_2 = ((__pyx_v_src_stride > 0) != 0);
-    if (__pyx_t_2) {
-    } else {
-      __pyx_t_1 = __pyx_t_2;
-      goto __pyx_L5_bool_binop_done;
-    }
-    __pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0);
-    if (__pyx_t_2) {
-    } else {
-      __pyx_t_1 = __pyx_t_2;
-      goto __pyx_L5_bool_binop_done;
-    }
-
-    /* "View.MemoryView":1154
- *     if ndim == 1:
- *        if (src_stride > 0 and dst_stride > 0 and
- *            <size_t> src_stride == itemsize == <size_t> dst_stride):             # <<<<<<<<<<<<<<
- *            memcpy(dst_data, src_data, itemsize * dst_extent)
- *        else:
- */
-    __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize);
-    if (__pyx_t_2) {
-      __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride));
-    }
-    __pyx_t_3 = (__pyx_t_2 != 0);
-    __pyx_t_1 = __pyx_t_3;
-    __pyx_L5_bool_binop_done:;
-
-    /* "View.MemoryView":1153
- * 
- *     if ndim == 1:
- *        if (src_stride > 0 and dst_stride > 0 and             # <<<<<<<<<<<<<<
- *            <size_t> src_stride == itemsize == <size_t> dst_stride):
- *            memcpy(dst_data, src_data, itemsize * dst_extent)
- */
-    if (__pyx_t_1) {
-
-      /* "View.MemoryView":1155
- *        if (src_stride > 0 and dst_stride > 0 and
- *            <size_t> src_stride == itemsize == <size_t> dst_stride):
- *            memcpy(dst_data, src_data, itemsize * dst_extent)             # <<<<<<<<<<<<<<
- *        else:
- *            for i in range(dst_extent):
- */
-      (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent)));
-
-      /* "View.MemoryView":1153
- * 
- *     if ndim == 1:
- *        if (src_stride > 0 and dst_stride > 0 and             # <<<<<<<<<<<<<<
- *            <size_t> src_stride == itemsize == <size_t> dst_stride):
- *            memcpy(dst_data, src_data, itemsize * dst_extent)
- */
-      goto __pyx_L4;
-    }
-
-    /* "View.MemoryView":1157
- *            memcpy(dst_data, src_data, itemsize * dst_extent)
- *        else:
- *            for i in range(dst_extent):             # <<<<<<<<<<<<<<
- *                memcpy(dst_data, src_data, itemsize)
- *                src_data += src_stride
- */
-    /*else*/ {
-      __pyx_t_4 = __pyx_v_dst_extent;
-      __pyx_t_5 = __pyx_t_4;
-      for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
-        __pyx_v_i = __pyx_t_6;
-
-        /* "View.MemoryView":1158
- *        else:
- *            for i in range(dst_extent):
- *                memcpy(dst_data, src_data, itemsize)             # <<<<<<<<<<<<<<
- *                src_data += src_stride
- *                dst_data += dst_stride
- */
-        (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize));
-
-        /* "View.MemoryView":1159
- *            for i in range(dst_extent):
- *                memcpy(dst_data, src_data, itemsize)
- *                src_data += src_stride             # <<<<<<<<<<<<<<
- *                dst_data += dst_stride
- *     else:
- */
-        __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride);
-
-        /* "View.MemoryView":1160
- *                memcpy(dst_data, src_data, itemsize)
- *                src_data += src_stride
- *                dst_data += dst_stride             # <<<<<<<<<<<<<<
- *     else:
- *         for i in range(dst_extent):
- */
-        __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride);
-      }
-    }
-    __pyx_L4:;
-
-    /* "View.MemoryView":1152
- *     cdef Py_ssize_t dst_stride = dst_strides[0]
- * 
- *     if ndim == 1:             # <<<<<<<<<<<<<<
- *        if (src_stride > 0 and dst_stride > 0 and
- *            <size_t> src_stride == itemsize == <size_t> dst_stride):
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":1162
- *                dst_data += dst_stride
- *     else:
- *         for i in range(dst_extent):             # <<<<<<<<<<<<<<
- *             _copy_strided_to_strided(src_data, src_strides + 1,
- *                                      dst_data, dst_strides + 1,
- */
-  /*else*/ {
-    __pyx_t_4 = __pyx_v_dst_extent;
-    __pyx_t_5 = __pyx_t_4;
-    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
-      __pyx_v_i = __pyx_t_6;
-
-      /* "View.MemoryView":1163
- *     else:
- *         for i in range(dst_extent):
- *             _copy_strided_to_strided(src_data, src_strides + 1,             # <<<<<<<<<<<<<<
- *                                      dst_data, dst_strides + 1,
- *                                      src_shape + 1, dst_shape + 1,
- */
-      _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize);
-
-      /* "View.MemoryView":1167
- *                                      src_shape + 1, dst_shape + 1,
- *                                      ndim - 1, itemsize)
- *             src_data += src_stride             # <<<<<<<<<<<<<<
- *             dst_data += dst_stride
- * 
- */
-      __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride);
-
-      /* "View.MemoryView":1168
- *                                      ndim - 1, itemsize)
- *             src_data += src_stride
- *             dst_data += dst_stride             # <<<<<<<<<<<<<<
- * 
- * cdef void copy_strided_to_strided(__Pyx_memviewslice *src,
- */
-      __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride);
-    }
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":1140
- * 
- * @cython.cdivision(True)
- * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides,             # <<<<<<<<<<<<<<
- *                                    char *dst_data, Py_ssize_t *dst_strides,
- *                                    Py_ssize_t *src_shape, Py_ssize_t *dst_shape,
- */
-
-  /* function exit code */
-}
-
-/* "View.MemoryView":1170
- *             dst_data += dst_stride
- * 
- * cdef void copy_strided_to_strided(__Pyx_memviewslice *src,             # <<<<<<<<<<<<<<
- *                                   __Pyx_memviewslice *dst,
- *                                   int ndim, size_t itemsize) nogil:
- */
-
-static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) {
-
-  /* "View.MemoryView":1173
- *                                   __Pyx_memviewslice *dst,
- *                                   int ndim, size_t itemsize) nogil:
- *     _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides,             # <<<<<<<<<<<<<<
- *                              src.shape, dst.shape, ndim, itemsize)
- * 
- */
-  _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize);
-
-  /* "View.MemoryView":1170
- *             dst_data += dst_stride
- * 
- * cdef void copy_strided_to_strided(__Pyx_memviewslice *src,             # <<<<<<<<<<<<<<
- *                                   __Pyx_memviewslice *dst,
- *                                   int ndim, size_t itemsize) nogil:
- */
-
-  /* function exit code */
-}
-
-/* "View.MemoryView":1177
- * 
- * @cname('__pyx_memoryview_slice_get_size')
- * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil:             # <<<<<<<<<<<<<<
- *     "Return the size of the memory occupied by the slice in number of bytes"
- *     cdef Py_ssize_t shape, size = src.memview.view.itemsize
- */
-
-static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) {
-  Py_ssize_t __pyx_v_shape;
-  Py_ssize_t __pyx_v_size;
-  Py_ssize_t __pyx_r;
-  Py_ssize_t __pyx_t_1;
-  Py_ssize_t *__pyx_t_2;
-  Py_ssize_t *__pyx_t_3;
-  Py_ssize_t *__pyx_t_4;
-
-  /* "View.MemoryView":1179
- * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil:
- *     "Return the size of the memory occupied by the slice in number of bytes"
- *     cdef Py_ssize_t shape, size = src.memview.view.itemsize             # <<<<<<<<<<<<<<
- * 
- *     for shape in src.shape[:ndim]:
- */
-  __pyx_t_1 = __pyx_v_src->memview->view.itemsize;
-  __pyx_v_size = __pyx_t_1;
-
-  /* "View.MemoryView":1181
- *     cdef Py_ssize_t shape, size = src.memview.view.itemsize
- * 
- *     for shape in src.shape[:ndim]:             # <<<<<<<<<<<<<<
- *         size *= shape
- * 
- */
-  __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim);
-  for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) {
-    __pyx_t_2 = __pyx_t_4;
-    __pyx_v_shape = (__pyx_t_2[0]);
-
-    /* "View.MemoryView":1182
- * 
- *     for shape in src.shape[:ndim]:
- *         size *= shape             # <<<<<<<<<<<<<<
- * 
- *     return size
- */
-    __pyx_v_size = (__pyx_v_size * __pyx_v_shape);
-  }
-
-  /* "View.MemoryView":1184
- *         size *= shape
- * 
- *     return size             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_fill_contig_strides_array')
- */
-  __pyx_r = __pyx_v_size;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":1177
- * 
- * @cname('__pyx_memoryview_slice_get_size')
- * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil:             # <<<<<<<<<<<<<<
- *     "Return the size of the memory occupied by the slice in number of bytes"
- *     cdef Py_ssize_t shape, size = src.memview.view.itemsize
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1187
- * 
- * @cname('__pyx_fill_contig_strides_array')
- * cdef Py_ssize_t fill_contig_strides_array(             # <<<<<<<<<<<<<<
- *                 Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride,
- *                 int ndim, char order) nogil:
- */
-
-static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) {
-  int __pyx_v_idx;
-  Py_ssize_t __pyx_r;
-  int __pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  int __pyx_t_4;
-
-  /* "View.MemoryView":1196
- *     cdef int idx
- * 
- *     if order == 'F':             # <<<<<<<<<<<<<<
- *         for idx in range(ndim):
- *             strides[idx] = stride
- */
-  __pyx_t_1 = ((__pyx_v_order == 'F') != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":1197
- * 
- *     if order == 'F':
- *         for idx in range(ndim):             # <<<<<<<<<<<<<<
- *             strides[idx] = stride
- *             stride *= shape[idx]
- */
-    __pyx_t_2 = __pyx_v_ndim;
-    __pyx_t_3 = __pyx_t_2;
-    for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
-      __pyx_v_idx = __pyx_t_4;
-
-      /* "View.MemoryView":1198
- *     if order == 'F':
- *         for idx in range(ndim):
- *             strides[idx] = stride             # <<<<<<<<<<<<<<
- *             stride *= shape[idx]
- *     else:
- */
-      (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride;
-
-      /* "View.MemoryView":1199
- *         for idx in range(ndim):
- *             strides[idx] = stride
- *             stride *= shape[idx]             # <<<<<<<<<<<<<<
- *     else:
- *         for idx in range(ndim - 1, -1, -1):
- */
-      __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx]));
-    }
-
-    /* "View.MemoryView":1196
- *     cdef int idx
- * 
- *     if order == 'F':             # <<<<<<<<<<<<<<
- *         for idx in range(ndim):
- *             strides[idx] = stride
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":1201
- *             stride *= shape[idx]
- *     else:
- *         for idx in range(ndim - 1, -1, -1):             # <<<<<<<<<<<<<<
- *             strides[idx] = stride
- *             stride *= shape[idx]
- */
-  /*else*/ {
-    for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) {
-      __pyx_v_idx = __pyx_t_2;
-
-      /* "View.MemoryView":1202
- *     else:
- *         for idx in range(ndim - 1, -1, -1):
- *             strides[idx] = stride             # <<<<<<<<<<<<<<
- *             stride *= shape[idx]
- * 
- */
-      (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride;
-
-      /* "View.MemoryView":1203
- *         for idx in range(ndim - 1, -1, -1):
- *             strides[idx] = stride
- *             stride *= shape[idx]             # <<<<<<<<<<<<<<
- * 
- *     return stride
- */
-      __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx]));
-    }
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":1205
- *             stride *= shape[idx]
- * 
- *     return stride             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_memoryview_copy_data_to_temp')
- */
-  __pyx_r = __pyx_v_stride;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":1187
- * 
- * @cname('__pyx_fill_contig_strides_array')
- * cdef Py_ssize_t fill_contig_strides_array(             # <<<<<<<<<<<<<<
- *                 Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride,
- *                 int ndim, char order) nogil:
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1208
- * 
- * @cname('__pyx_memoryview_copy_data_to_temp')
- * cdef void *copy_data_to_temp(__Pyx_memviewslice *src,             # <<<<<<<<<<<<<<
- *                              __Pyx_memviewslice *tmpslice,
- *                              char order,
- */
-
-static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) {
-  int __pyx_v_i;
-  void *__pyx_v_result;
-  size_t __pyx_v_itemsize;
-  size_t __pyx_v_size;
-  void *__pyx_r;
-  Py_ssize_t __pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  struct __pyx_memoryview_obj *__pyx_t_4;
-  int __pyx_t_5;
-  int __pyx_t_6;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-
-  /* "View.MemoryView":1219
- *     cdef void *result
- * 
- *     cdef size_t itemsize = src.memview.view.itemsize             # <<<<<<<<<<<<<<
- *     cdef size_t size = slice_get_size(src, ndim)
- * 
- */
-  __pyx_t_1 = __pyx_v_src->memview->view.itemsize;
-  __pyx_v_itemsize = __pyx_t_1;
-
-  /* "View.MemoryView":1220
- * 
- *     cdef size_t itemsize = src.memview.view.itemsize
- *     cdef size_t size = slice_get_size(src, ndim)             # <<<<<<<<<<<<<<
- * 
- *     result = malloc(size)
- */
-  __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim);
-
-  /* "View.MemoryView":1222
- *     cdef size_t size = slice_get_size(src, ndim)
- * 
- *     result = malloc(size)             # <<<<<<<<<<<<<<
- *     if not result:
- *         _err(MemoryError, NULL)
- */
-  __pyx_v_result = malloc(__pyx_v_size);
-
-  /* "View.MemoryView":1223
- * 
- *     result = malloc(size)
- *     if not result:             # <<<<<<<<<<<<<<
- *         _err(MemoryError, NULL)
- * 
- */
-  __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":1224
- *     result = malloc(size)
- *     if not result:
- *         _err(MemoryError, NULL)             # <<<<<<<<<<<<<<
- * 
- * 
- */
-    __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1224, __pyx_L1_error)
-
-    /* "View.MemoryView":1223
- * 
- *     result = malloc(size)
- *     if not result:             # <<<<<<<<<<<<<<
- *         _err(MemoryError, NULL)
- * 
- */
-  }
-
-  /* "View.MemoryView":1227
- * 
- * 
- *     tmpslice.data = <char *> result             # <<<<<<<<<<<<<<
- *     tmpslice.memview = src.memview
- *     for i in range(ndim):
- */
-  __pyx_v_tmpslice->data = ((char *)__pyx_v_result);
-
-  /* "View.MemoryView":1228
- * 
- *     tmpslice.data = <char *> result
- *     tmpslice.memview = src.memview             # <<<<<<<<<<<<<<
- *     for i in range(ndim):
- *         tmpslice.shape[i] = src.shape[i]
- */
-  __pyx_t_4 = __pyx_v_src->memview;
-  __pyx_v_tmpslice->memview = __pyx_t_4;
-
-  /* "View.MemoryView":1229
- *     tmpslice.data = <char *> result
- *     tmpslice.memview = src.memview
- *     for i in range(ndim):             # <<<<<<<<<<<<<<
- *         tmpslice.shape[i] = src.shape[i]
- *         tmpslice.suboffsets[i] = -1
- */
-  __pyx_t_3 = __pyx_v_ndim;
-  __pyx_t_5 = __pyx_t_3;
-  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
-    __pyx_v_i = __pyx_t_6;
-
-    /* "View.MemoryView":1230
- *     tmpslice.memview = src.memview
- *     for i in range(ndim):
- *         tmpslice.shape[i] = src.shape[i]             # <<<<<<<<<<<<<<
- *         tmpslice.suboffsets[i] = -1
- * 
- */
-    (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]);
-
-    /* "View.MemoryView":1231
- *     for i in range(ndim):
- *         tmpslice.shape[i] = src.shape[i]
- *         tmpslice.suboffsets[i] = -1             # <<<<<<<<<<<<<<
- * 
- *     fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize,
- */
-    (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L;
-  }
-
-  /* "View.MemoryView":1233
- *         tmpslice.suboffsets[i] = -1
- * 
- *     fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize,             # <<<<<<<<<<<<<<
- *                               ndim, order)
- * 
- */
-  (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order));
-
-  /* "View.MemoryView":1237
- * 
- * 
- *     for i in range(ndim):             # <<<<<<<<<<<<<<
- *         if tmpslice.shape[i] == 1:
- *             tmpslice.strides[i] = 0
- */
-  __pyx_t_3 = __pyx_v_ndim;
-  __pyx_t_5 = __pyx_t_3;
-  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
-    __pyx_v_i = __pyx_t_6;
-
-    /* "View.MemoryView":1238
- * 
- *     for i in range(ndim):
- *         if tmpslice.shape[i] == 1:             # <<<<<<<<<<<<<<
- *             tmpslice.strides[i] = 0
- * 
- */
-    __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":1239
- *     for i in range(ndim):
- *         if tmpslice.shape[i] == 1:
- *             tmpslice.strides[i] = 0             # <<<<<<<<<<<<<<
- * 
- *     if slice_is_contig(src[0], order, ndim):
- */
-      (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0;
-
-      /* "View.MemoryView":1238
- * 
- *     for i in range(ndim):
- *         if tmpslice.shape[i] == 1:             # <<<<<<<<<<<<<<
- *             tmpslice.strides[i] = 0
- * 
- */
-    }
-  }
-
-  /* "View.MemoryView":1241
- *             tmpslice.strides[i] = 0
- * 
- *     if slice_is_contig(src[0], order, ndim):             # <<<<<<<<<<<<<<
- *         memcpy(result, src.data, size)
- *     else:
- */
-  __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":1242
- * 
- *     if slice_is_contig(src[0], order, ndim):
- *         memcpy(result, src.data, size)             # <<<<<<<<<<<<<<
- *     else:
- *         copy_strided_to_strided(src, tmpslice, ndim, itemsize)
- */
-    (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size));
-
-    /* "View.MemoryView":1241
- *             tmpslice.strides[i] = 0
- * 
- *     if slice_is_contig(src[0], order, ndim):             # <<<<<<<<<<<<<<
- *         memcpy(result, src.data, size)
- *     else:
- */
-    goto __pyx_L9;
-  }
-
-  /* "View.MemoryView":1244
- *         memcpy(result, src.data, size)
- *     else:
- *         copy_strided_to_strided(src, tmpslice, ndim, itemsize)             # <<<<<<<<<<<<<<
- * 
- *     return result
- */
-  /*else*/ {
-    copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize);
-  }
-  __pyx_L9:;
-
-  /* "View.MemoryView":1246
- *         copy_strided_to_strided(src, tmpslice, ndim, itemsize)
- * 
- *     return result             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_r = __pyx_v_result;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":1208
- * 
- * @cname('__pyx_memoryview_copy_data_to_temp')
- * cdef void *copy_data_to_temp(__Pyx_memviewslice *src,             # <<<<<<<<<<<<<<
- *                              __Pyx_memviewslice *tmpslice,
- *                              char order,
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  {
-    #ifdef WITH_THREAD
-    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-    #endif
-    __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename);
-    #ifdef WITH_THREAD
-    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-    #endif
-  }
-  __pyx_r = NULL;
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1251
- * 
- * @cname('__pyx_memoryview_err_extents')
- * cdef int _err_extents(int i, Py_ssize_t extent1,             # <<<<<<<<<<<<<<
- *                              Py_ssize_t extent2) except -1 with gil:
- *     raise ValueError("got differing extents in dimension %d (got %d and %d)" %
- */
-
-static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  #ifdef WITH_THREAD
-  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-  #endif
-  __Pyx_RefNannySetupContext("_err_extents", 0);
-
-  /* "View.MemoryView":1254
- *                              Py_ssize_t extent2) except -1 with gil:
- *     raise ValueError("got differing extents in dimension %d (got %d and %d)" %
- *                                                         (i, extent1, extent2))             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_memoryview_err_dim')
- */
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1254, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1254, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1254, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1254, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3);
-  __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_t_3 = 0;
-
-  /* "View.MemoryView":1253
- * cdef int _err_extents(int i, Py_ssize_t extent1,
- *                              Py_ssize_t extent2) except -1 with gil:
- *     raise ValueError("got differing extents in dimension %d (got %d and %d)" %             # <<<<<<<<<<<<<<
- *                                                         (i, extent1, extent2))
- * 
- */
-  __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1253, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1253, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_Raise(__pyx_t_4, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __PYX_ERR(1, 1253, __pyx_L1_error)
-
-  /* "View.MemoryView":1251
- * 
- * @cname('__pyx_memoryview_err_extents')
- * cdef int _err_extents(int i, Py_ssize_t extent1,             # <<<<<<<<<<<<<<
- *                              Py_ssize_t extent2) except -1 with gil:
- *     raise ValueError("got differing extents in dimension %d (got %d and %d)" %
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __Pyx_RefNannyFinishContext();
-  #ifdef WITH_THREAD
-  __Pyx_PyGILState_Release(__pyx_gilstate_save);
-  #endif
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1257
- * 
- * @cname('__pyx_memoryview_err_dim')
- * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil:             # <<<<<<<<<<<<<<
- *     raise error(msg.decode('ascii') % dim)
- * 
- */
-
-static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  #ifdef WITH_THREAD
-  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-  #endif
-  __Pyx_RefNannySetupContext("_err_dim", 0);
-  __Pyx_INCREF(__pyx_v_error);
-
-  /* "View.MemoryView":1258
- * @cname('__pyx_memoryview_err_dim')
- * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil:
- *     raise error(msg.decode('ascii') % dim)             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_memoryview_err')
- */
-  __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1258, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1258, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1258, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_INCREF(__pyx_v_error);
-  __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
-    if (likely(__pyx_t_2)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-      __Pyx_INCREF(__pyx_t_2);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_3, function);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1258, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(1, 1258, __pyx_L1_error)
-
-  /* "View.MemoryView":1257
- * 
- * @cname('__pyx_memoryview_err_dim')
- * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil:             # <<<<<<<<<<<<<<
- *     raise error(msg.decode('ascii') % dim)
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __Pyx_XDECREF(__pyx_v_error);
-  __Pyx_RefNannyFinishContext();
-  #ifdef WITH_THREAD
-  __Pyx_PyGILState_Release(__pyx_gilstate_save);
-  #endif
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1261
- * 
- * @cname('__pyx_memoryview_err')
- * cdef int _err(object error, char *msg) except -1 with gil:             # <<<<<<<<<<<<<<
- *     if msg != NULL:
- *         raise error(msg.decode('ascii'))
- */
-
-static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  #ifdef WITH_THREAD
-  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-  #endif
-  __Pyx_RefNannySetupContext("_err", 0);
-  __Pyx_INCREF(__pyx_v_error);
-
-  /* "View.MemoryView":1262
- * @cname('__pyx_memoryview_err')
- * cdef int _err(object error, char *msg) except -1 with gil:
- *     if msg != NULL:             # <<<<<<<<<<<<<<
- *         raise error(msg.decode('ascii'))
- *     else:
- */
-  __pyx_t_1 = ((__pyx_v_msg != NULL) != 0);
-  if (unlikely(__pyx_t_1)) {
-
-    /* "View.MemoryView":1263
- * cdef int _err(object error, char *msg) except -1 with gil:
- *     if msg != NULL:
- *         raise error(msg.decode('ascii'))             # <<<<<<<<<<<<<<
- *     else:
- *         raise error
- */
-    __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1263, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_INCREF(__pyx_v_error);
-    __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
-      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
-      if (likely(__pyx_t_5)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
-        __Pyx_INCREF(__pyx_t_5);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_4, function);
-      }
-    }
-    __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3);
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1263, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(1, 1263, __pyx_L1_error)
-
-    /* "View.MemoryView":1262
- * @cname('__pyx_memoryview_err')
- * cdef int _err(object error, char *msg) except -1 with gil:
- *     if msg != NULL:             # <<<<<<<<<<<<<<
- *         raise error(msg.decode('ascii'))
- *     else:
- */
-  }
-
-  /* "View.MemoryView":1265
- *         raise error(msg.decode('ascii'))
- *     else:
- *         raise error             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_memoryview_copy_contents')
- */
-  /*else*/ {
-    __Pyx_Raise(__pyx_v_error, 0, 0, 0);
-    __PYX_ERR(1, 1265, __pyx_L1_error)
-  }
-
-  /* "View.MemoryView":1261
- * 
- * @cname('__pyx_memoryview_err')
- * cdef int _err(object error, char *msg) except -1 with gil:             # <<<<<<<<<<<<<<
- *     if msg != NULL:
- *         raise error(msg.decode('ascii'))
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __Pyx_XDECREF(__pyx_v_error);
-  __Pyx_RefNannyFinishContext();
-  #ifdef WITH_THREAD
-  __Pyx_PyGILState_Release(__pyx_gilstate_save);
-  #endif
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1268
- * 
- * @cname('__pyx_memoryview_copy_contents')
- * cdef int memoryview_copy_contents(__Pyx_memviewslice src,             # <<<<<<<<<<<<<<
- *                                   __Pyx_memviewslice dst,
- *                                   int src_ndim, int dst_ndim,
- */
-
-static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) {
-  void *__pyx_v_tmpdata;
-  size_t __pyx_v_itemsize;
-  int __pyx_v_i;
-  char __pyx_v_order;
-  int __pyx_v_broadcasting;
-  int __pyx_v_direct_copy;
-  __Pyx_memviewslice __pyx_v_tmp;
-  int __pyx_v_ndim;
-  int __pyx_r;
-  Py_ssize_t __pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  int __pyx_t_4;
-  int __pyx_t_5;
-  int __pyx_t_6;
-  void *__pyx_t_7;
-  int __pyx_t_8;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-
-  /* "View.MemoryView":1276
- *     Check for overlapping memory and verify the shapes.
- *     """
- *     cdef void *tmpdata = NULL             # <<<<<<<<<<<<<<
- *     cdef size_t itemsize = src.memview.view.itemsize
- *     cdef int i
- */
-  __pyx_v_tmpdata = NULL;
-
-  /* "View.MemoryView":1277
- *     """
- *     cdef void *tmpdata = NULL
- *     cdef size_t itemsize = src.memview.view.itemsize             # <<<<<<<<<<<<<<
- *     cdef int i
- *     cdef char order = get_best_order(&src, src_ndim)
- */
-  __pyx_t_1 = __pyx_v_src.memview->view.itemsize;
-  __pyx_v_itemsize = __pyx_t_1;
-
-  /* "View.MemoryView":1279
- *     cdef size_t itemsize = src.memview.view.itemsize
- *     cdef int i
- *     cdef char order = get_best_order(&src, src_ndim)             # <<<<<<<<<<<<<<
- *     cdef bint broadcasting = False
- *     cdef bint direct_copy = False
- */
-  __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim);
-
-  /* "View.MemoryView":1280
- *     cdef int i
- *     cdef char order = get_best_order(&src, src_ndim)
- *     cdef bint broadcasting = False             # <<<<<<<<<<<<<<
- *     cdef bint direct_copy = False
- *     cdef __Pyx_memviewslice tmp
- */
-  __pyx_v_broadcasting = 0;
-
-  /* "View.MemoryView":1281
- *     cdef char order = get_best_order(&src, src_ndim)
- *     cdef bint broadcasting = False
- *     cdef bint direct_copy = False             # <<<<<<<<<<<<<<
- *     cdef __Pyx_memviewslice tmp
- * 
- */
-  __pyx_v_direct_copy = 0;
-
-  /* "View.MemoryView":1284
- *     cdef __Pyx_memviewslice tmp
- * 
- *     if src_ndim < dst_ndim:             # <<<<<<<<<<<<<<
- *         broadcast_leading(&src, src_ndim, dst_ndim)
- *     elif dst_ndim < src_ndim:
- */
-  __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":1285
- * 
- *     if src_ndim < dst_ndim:
- *         broadcast_leading(&src, src_ndim, dst_ndim)             # <<<<<<<<<<<<<<
- *     elif dst_ndim < src_ndim:
- *         broadcast_leading(&dst, dst_ndim, src_ndim)
- */
-    __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim);
-
-    /* "View.MemoryView":1284
- *     cdef __Pyx_memviewslice tmp
- * 
- *     if src_ndim < dst_ndim:             # <<<<<<<<<<<<<<
- *         broadcast_leading(&src, src_ndim, dst_ndim)
- *     elif dst_ndim < src_ndim:
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":1286
- *     if src_ndim < dst_ndim:
- *         broadcast_leading(&src, src_ndim, dst_ndim)
- *     elif dst_ndim < src_ndim:             # <<<<<<<<<<<<<<
- *         broadcast_leading(&dst, dst_ndim, src_ndim)
- * 
- */
-  __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":1287
- *         broadcast_leading(&src, src_ndim, dst_ndim)
- *     elif dst_ndim < src_ndim:
- *         broadcast_leading(&dst, dst_ndim, src_ndim)             # <<<<<<<<<<<<<<
- * 
- *     cdef int ndim = max(src_ndim, dst_ndim)
- */
-    __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim);
-
-    /* "View.MemoryView":1286
- *     if src_ndim < dst_ndim:
- *         broadcast_leading(&src, src_ndim, dst_ndim)
- *     elif dst_ndim < src_ndim:             # <<<<<<<<<<<<<<
- *         broadcast_leading(&dst, dst_ndim, src_ndim)
- * 
- */
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":1289
- *         broadcast_leading(&dst, dst_ndim, src_ndim)
- * 
- *     cdef int ndim = max(src_ndim, dst_ndim)             # <<<<<<<<<<<<<<
- * 
- *     for i in range(ndim):
- */
-  __pyx_t_3 = __pyx_v_dst_ndim;
-  __pyx_t_4 = __pyx_v_src_ndim;
-  if (((__pyx_t_3 > __pyx_t_4) != 0)) {
-    __pyx_t_5 = __pyx_t_3;
-  } else {
-    __pyx_t_5 = __pyx_t_4;
-  }
-  __pyx_v_ndim = __pyx_t_5;
-
-  /* "View.MemoryView":1291
- *     cdef int ndim = max(src_ndim, dst_ndim)
- * 
- *     for i in range(ndim):             # <<<<<<<<<<<<<<
- *         if src.shape[i] != dst.shape[i]:
- *             if src.shape[i] == 1:
- */
-  __pyx_t_5 = __pyx_v_ndim;
-  __pyx_t_3 = __pyx_t_5;
-  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
-    __pyx_v_i = __pyx_t_4;
-
-    /* "View.MemoryView":1292
- * 
- *     for i in range(ndim):
- *         if src.shape[i] != dst.shape[i]:             # <<<<<<<<<<<<<<
- *             if src.shape[i] == 1:
- *                 broadcasting = True
- */
-    __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":1293
- *     for i in range(ndim):
- *         if src.shape[i] != dst.shape[i]:
- *             if src.shape[i] == 1:             # <<<<<<<<<<<<<<
- *                 broadcasting = True
- *                 src.strides[i] = 0
- */
-      __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0);
-      if (__pyx_t_2) {
-
-        /* "View.MemoryView":1294
- *         if src.shape[i] != dst.shape[i]:
- *             if src.shape[i] == 1:
- *                 broadcasting = True             # <<<<<<<<<<<<<<
- *                 src.strides[i] = 0
- *             else:
- */
-        __pyx_v_broadcasting = 1;
-
-        /* "View.MemoryView":1295
- *             if src.shape[i] == 1:
- *                 broadcasting = True
- *                 src.strides[i] = 0             # <<<<<<<<<<<<<<
- *             else:
- *                 _err_extents(i, dst.shape[i], src.shape[i])
- */
-        (__pyx_v_src.strides[__pyx_v_i]) = 0;
-
-        /* "View.MemoryView":1293
- *     for i in range(ndim):
- *         if src.shape[i] != dst.shape[i]:
- *             if src.shape[i] == 1:             # <<<<<<<<<<<<<<
- *                 broadcasting = True
- *                 src.strides[i] = 0
- */
-        goto __pyx_L7;
-      }
-
-      /* "View.MemoryView":1297
- *                 src.strides[i] = 0
- *             else:
- *                 _err_extents(i, dst.shape[i], src.shape[i])             # <<<<<<<<<<<<<<
- * 
- *         if src.suboffsets[i] >= 0:
- */
-      /*else*/ {
-        __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1297, __pyx_L1_error)
-      }
-      __pyx_L7:;
-
-      /* "View.MemoryView":1292
- * 
- *     for i in range(ndim):
- *         if src.shape[i] != dst.shape[i]:             # <<<<<<<<<<<<<<
- *             if src.shape[i] == 1:
- *                 broadcasting = True
- */
-    }
-
-    /* "View.MemoryView":1299
- *                 _err_extents(i, dst.shape[i], src.shape[i])
- * 
- *         if src.suboffsets[i] >= 0:             # <<<<<<<<<<<<<<
- *             _err_dim(ValueError, "Dimension %d is not direct", i)
- * 
- */
-    __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":1300
- * 
- *         if src.suboffsets[i] >= 0:
- *             _err_dim(ValueError, "Dimension %d is not direct", i)             # <<<<<<<<<<<<<<
- * 
- *     if slices_overlap(&src, &dst, ndim, itemsize):
- */
-      __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1300, __pyx_L1_error)
-
-      /* "View.MemoryView":1299
- *                 _err_extents(i, dst.shape[i], src.shape[i])
- * 
- *         if src.suboffsets[i] >= 0:             # <<<<<<<<<<<<<<
- *             _err_dim(ValueError, "Dimension %d is not direct", i)
- * 
- */
-    }
-  }
-
-  /* "View.MemoryView":1302
- *             _err_dim(ValueError, "Dimension %d is not direct", i)
- * 
- *     if slices_overlap(&src, &dst, ndim, itemsize):             # <<<<<<<<<<<<<<
- * 
- *         if not slice_is_contig(src, order, ndim):
- */
-  __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":1304
- *     if slices_overlap(&src, &dst, ndim, itemsize):
- * 
- *         if not slice_is_contig(src, order, ndim):             # <<<<<<<<<<<<<<
- *             order = get_best_order(&dst, ndim)
- * 
- */
-    __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":1305
- * 
- *         if not slice_is_contig(src, order, ndim):
- *             order = get_best_order(&dst, ndim)             # <<<<<<<<<<<<<<
- * 
- *         tmpdata = copy_data_to_temp(&src, &tmp, order, ndim)
- */
-      __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim);
-
-      /* "View.MemoryView":1304
- *     if slices_overlap(&src, &dst, ndim, itemsize):
- * 
- *         if not slice_is_contig(src, order, ndim):             # <<<<<<<<<<<<<<
- *             order = get_best_order(&dst, ndim)
- * 
- */
-    }
-
-    /* "View.MemoryView":1307
- *             order = get_best_order(&dst, ndim)
- * 
- *         tmpdata = copy_data_to_temp(&src, &tmp, order, ndim)             # <<<<<<<<<<<<<<
- *         src = tmp
- * 
- */
-    __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 1307, __pyx_L1_error)
-    __pyx_v_tmpdata = __pyx_t_7;
-
-    /* "View.MemoryView":1308
- * 
- *         tmpdata = copy_data_to_temp(&src, &tmp, order, ndim)
- *         src = tmp             # <<<<<<<<<<<<<<
- * 
- *     if not broadcasting:
- */
-    __pyx_v_src = __pyx_v_tmp;
-
-    /* "View.MemoryView":1302
- *             _err_dim(ValueError, "Dimension %d is not direct", i)
- * 
- *     if slices_overlap(&src, &dst, ndim, itemsize):             # <<<<<<<<<<<<<<
- * 
- *         if not slice_is_contig(src, order, ndim):
- */
-  }
-
-  /* "View.MemoryView":1310
- *         src = tmp
- * 
- *     if not broadcasting:             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0);
-  if (__pyx_t_2) {
-
-    /* "View.MemoryView":1313
- * 
- * 
- *         if slice_is_contig(src, 'C', ndim):             # <<<<<<<<<<<<<<
- *             direct_copy = slice_is_contig(dst, 'C', ndim)
- *         elif slice_is_contig(src, 'F', ndim):
- */
-    __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":1314
- * 
- *         if slice_is_contig(src, 'C', ndim):
- *             direct_copy = slice_is_contig(dst, 'C', ndim)             # <<<<<<<<<<<<<<
- *         elif slice_is_contig(src, 'F', ndim):
- *             direct_copy = slice_is_contig(dst, 'F', ndim)
- */
-      __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim);
-
-      /* "View.MemoryView":1313
- * 
- * 
- *         if slice_is_contig(src, 'C', ndim):             # <<<<<<<<<<<<<<
- *             direct_copy = slice_is_contig(dst, 'C', ndim)
- *         elif slice_is_contig(src, 'F', ndim):
- */
-      goto __pyx_L12;
-    }
-
-    /* "View.MemoryView":1315
- *         if slice_is_contig(src, 'C', ndim):
- *             direct_copy = slice_is_contig(dst, 'C', ndim)
- *         elif slice_is_contig(src, 'F', ndim):             # <<<<<<<<<<<<<<
- *             direct_copy = slice_is_contig(dst, 'F', ndim)
- * 
- */
-    __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":1316
- *             direct_copy = slice_is_contig(dst, 'C', ndim)
- *         elif slice_is_contig(src, 'F', ndim):
- *             direct_copy = slice_is_contig(dst, 'F', ndim)             # <<<<<<<<<<<<<<
- * 
- *         if direct_copy:
- */
-      __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim);
-
-      /* "View.MemoryView":1315
- *         if slice_is_contig(src, 'C', ndim):
- *             direct_copy = slice_is_contig(dst, 'C', ndim)
- *         elif slice_is_contig(src, 'F', ndim):             # <<<<<<<<<<<<<<
- *             direct_copy = slice_is_contig(dst, 'F', ndim)
- * 
- */
-    }
-    __pyx_L12:;
-
-    /* "View.MemoryView":1318
- *             direct_copy = slice_is_contig(dst, 'F', ndim)
- * 
- *         if direct_copy:             # <<<<<<<<<<<<<<
- * 
- *             refcount_copying(&dst, dtype_is_object, ndim, False)
- */
-    __pyx_t_2 = (__pyx_v_direct_copy != 0);
-    if (__pyx_t_2) {
-
-      /* "View.MemoryView":1320
- *         if direct_copy:
- * 
- *             refcount_copying(&dst, dtype_is_object, ndim, False)             # <<<<<<<<<<<<<<
- *             memcpy(dst.data, src.data, slice_get_size(&src, ndim))
- *             refcount_copying(&dst, dtype_is_object, ndim, True)
- */
-      __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0);
-
-      /* "View.MemoryView":1321
- * 
- *             refcount_copying(&dst, dtype_is_object, ndim, False)
- *             memcpy(dst.data, src.data, slice_get_size(&src, ndim))             # <<<<<<<<<<<<<<
- *             refcount_copying(&dst, dtype_is_object, ndim, True)
- *             free(tmpdata)
- */
-      (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim)));
-
-      /* "View.MemoryView":1322
- *             refcount_copying(&dst, dtype_is_object, ndim, False)
- *             memcpy(dst.data, src.data, slice_get_size(&src, ndim))
- *             refcount_copying(&dst, dtype_is_object, ndim, True)             # <<<<<<<<<<<<<<
- *             free(tmpdata)
- *             return 0
- */
-      __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1);
-
-      /* "View.MemoryView":1323
- *             memcpy(dst.data, src.data, slice_get_size(&src, ndim))
- *             refcount_copying(&dst, dtype_is_object, ndim, True)
- *             free(tmpdata)             # <<<<<<<<<<<<<<
- *             return 0
- * 
- */
-      free(__pyx_v_tmpdata);
-
-      /* "View.MemoryView":1324
- *             refcount_copying(&dst, dtype_is_object, ndim, True)
- *             free(tmpdata)
- *             return 0             # <<<<<<<<<<<<<<
- * 
- *     if order == 'F' == get_best_order(&dst, ndim):
- */
-      __pyx_r = 0;
-      goto __pyx_L0;
-
-      /* "View.MemoryView":1318
- *             direct_copy = slice_is_contig(dst, 'F', ndim)
- * 
- *         if direct_copy:             # <<<<<<<<<<<<<<
- * 
- *             refcount_copying(&dst, dtype_is_object, ndim, False)
- */
-    }
-
-    /* "View.MemoryView":1310
- *         src = tmp
- * 
- *     if not broadcasting:             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  }
-
-  /* "View.MemoryView":1326
- *             return 0
- * 
- *     if order == 'F' == get_best_order(&dst, ndim):             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_2 = (__pyx_v_order == 'F');
-  if (__pyx_t_2) {
-    __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim));
-  }
-  __pyx_t_8 = (__pyx_t_2 != 0);
-  if (__pyx_t_8) {
-
-    /* "View.MemoryView":1329
- * 
- * 
- *         transpose_memslice(&src)             # <<<<<<<<<<<<<<
- *         transpose_memslice(&dst)
- * 
- */
-    __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1329, __pyx_L1_error)
-
-    /* "View.MemoryView":1330
- * 
- *         transpose_memslice(&src)
- *         transpose_memslice(&dst)             # <<<<<<<<<<<<<<
- * 
- *     refcount_copying(&dst, dtype_is_object, ndim, False)
- */
-    __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1330, __pyx_L1_error)
-
-    /* "View.MemoryView":1326
- *             return 0
- * 
- *     if order == 'F' == get_best_order(&dst, ndim):             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  }
-
-  /* "View.MemoryView":1332
- *         transpose_memslice(&dst)
- * 
- *     refcount_copying(&dst, dtype_is_object, ndim, False)             # <<<<<<<<<<<<<<
- *     copy_strided_to_strided(&src, &dst, ndim, itemsize)
- *     refcount_copying(&dst, dtype_is_object, ndim, True)
- */
-  __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0);
-
-  /* "View.MemoryView":1333
- * 
- *     refcount_copying(&dst, dtype_is_object, ndim, False)
- *     copy_strided_to_strided(&src, &dst, ndim, itemsize)             # <<<<<<<<<<<<<<
- *     refcount_copying(&dst, dtype_is_object, ndim, True)
- * 
- */
-  copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize);
-
-  /* "View.MemoryView":1334
- *     refcount_copying(&dst, dtype_is_object, ndim, False)
- *     copy_strided_to_strided(&src, &dst, ndim, itemsize)
- *     refcount_copying(&dst, dtype_is_object, ndim, True)             # <<<<<<<<<<<<<<
- * 
- *     free(tmpdata)
- */
-  __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1);
-
-  /* "View.MemoryView":1336
- *     refcount_copying(&dst, dtype_is_object, ndim, True)
- * 
- *     free(tmpdata)             # <<<<<<<<<<<<<<
- *     return 0
- * 
- */
-  free(__pyx_v_tmpdata);
-
-  /* "View.MemoryView":1337
- * 
- *     free(tmpdata)
- *     return 0             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_memoryview_broadcast_leading')
- */
-  __pyx_r = 0;
-  goto __pyx_L0;
-
-  /* "View.MemoryView":1268
- * 
- * @cname('__pyx_memoryview_copy_contents')
- * cdef int memoryview_copy_contents(__Pyx_memviewslice src,             # <<<<<<<<<<<<<<
- *                                   __Pyx_memviewslice dst,
- *                                   int src_ndim, int dst_ndim,
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  {
-    #ifdef WITH_THREAD
-    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-    #endif
-    __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename);
-    #ifdef WITH_THREAD
-    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-    #endif
-  }
-  __pyx_r = -1;
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "View.MemoryView":1340
- * 
- * @cname('__pyx_memoryview_broadcast_leading')
- * cdef void broadcast_leading(__Pyx_memviewslice *mslice,             # <<<<<<<<<<<<<<
- *                             int ndim,
- *                             int ndim_other) nogil:
- */
-
-static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) {
-  int __pyx_v_i;
-  int __pyx_v_offset;
-  int __pyx_t_1;
-  int __pyx_t_2;
-  int __pyx_t_3;
-
-  /* "View.MemoryView":1344
- *                             int ndim_other) nogil:
- *     cdef int i
- *     cdef int offset = ndim_other - ndim             # <<<<<<<<<<<<<<
- * 
- *     for i in range(ndim - 1, -1, -1):
- */
-  __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim);
-
-  /* "View.MemoryView":1346
- *     cdef int offset = ndim_other - ndim
- * 
- *     for i in range(ndim - 1, -1, -1):             # <<<<<<<<<<<<<<
- *         mslice.shape[i + offset] = mslice.shape[i]
- *         mslice.strides[i + offset] = mslice.strides[i]
- */
-  for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) {
-    __pyx_v_i = __pyx_t_1;
-
-    /* "View.MemoryView":1347
- * 
- *     for i in range(ndim - 1, -1, -1):
- *         mslice.shape[i + offset] = mslice.shape[i]             # <<<<<<<<<<<<<<
- *         mslice.strides[i + offset] = mslice.strides[i]
- *         mslice.suboffsets[i + offset] = mslice.suboffsets[i]
- */
-    (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]);
-
-    /* "View.MemoryView":1348
- *     for i in range(ndim - 1, -1, -1):
- *         mslice.shape[i + offset] = mslice.shape[i]
- *         mslice.strides[i + offset] = mslice.strides[i]             # <<<<<<<<<<<<<<
- *         mslice.suboffsets[i + offset] = mslice.suboffsets[i]
- * 
- */
-    (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]);
-
-    /* "View.MemoryView":1349
- *         mslice.shape[i + offset] = mslice.shape[i]
- *         mslice.strides[i + offset] = mslice.strides[i]
- *         mslice.suboffsets[i + offset] = mslice.suboffsets[i]             # <<<<<<<<<<<<<<
- * 
- *     for i in range(offset):
- */
-    (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]);
-  }
-
-  /* "View.MemoryView":1351
- *         mslice.suboffsets[i + offset] = mslice.suboffsets[i]
- * 
- *     for i in range(offset):             # <<<<<<<<<<<<<<
- *         mslice.shape[i] = 1
- *         mslice.strides[i] = mslice.strides[0]
- */
-  __pyx_t_1 = __pyx_v_offset;
-  __pyx_t_2 = __pyx_t_1;
-  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
-    __pyx_v_i = __pyx_t_3;
-
-    /* "View.MemoryView":1352
- * 
- *     for i in range(offset):
- *         mslice.shape[i] = 1             # <<<<<<<<<<<<<<
- *         mslice.strides[i] = mslice.strides[0]
- *         mslice.suboffsets[i] = -1
- */
-    (__pyx_v_mslice->shape[__pyx_v_i]) = 1;
-
-    /* "View.MemoryView":1353
- *     for i in range(offset):
- *         mslice.shape[i] = 1
- *         mslice.strides[i] = mslice.strides[0]             # <<<<<<<<<<<<<<
- *         mslice.suboffsets[i] = -1
- * 
- */
-    (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]);
-
-    /* "View.MemoryView":1354
- *         mslice.shape[i] = 1
- *         mslice.strides[i] = mslice.strides[0]
- *         mslice.suboffsets[i] = -1             # <<<<<<<<<<<<<<
- * 
- * 
- */
-    (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L;
-  }
-
-  /* "View.MemoryView":1340
- * 
- * @cname('__pyx_memoryview_broadcast_leading')
- * cdef void broadcast_leading(__Pyx_memviewslice *mslice,             # <<<<<<<<<<<<<<
- *                             int ndim,
- *                             int ndim_other) nogil:
- */
-
-  /* function exit code */
-}
-
-/* "View.MemoryView":1362
- * 
- * @cname('__pyx_memoryview_refcount_copying')
- * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object,             # <<<<<<<<<<<<<<
- *                            int ndim, bint inc) nogil:
- * 
- */
-
-static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) {
-  int __pyx_t_1;
-
-  /* "View.MemoryView":1366
- * 
- * 
- *     if dtype_is_object:             # <<<<<<<<<<<<<<
- *         refcount_objects_in_slice_with_gil(dst.data, dst.shape,
- *                                            dst.strides, ndim, inc)
- */
-  __pyx_t_1 = (__pyx_v_dtype_is_object != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":1367
- * 
- *     if dtype_is_object:
- *         refcount_objects_in_slice_with_gil(dst.data, dst.shape,             # <<<<<<<<<<<<<<
- *                                            dst.strides, ndim, inc)
- * 
- */
-    __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc);
-
-    /* "View.MemoryView":1366
- * 
- * 
- *     if dtype_is_object:             # <<<<<<<<<<<<<<
- *         refcount_objects_in_slice_with_gil(dst.data, dst.shape,
- *                                            dst.strides, ndim, inc)
- */
-  }
-
-  /* "View.MemoryView":1362
- * 
- * @cname('__pyx_memoryview_refcount_copying')
- * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object,             # <<<<<<<<<<<<<<
- *                            int ndim, bint inc) nogil:
- * 
- */
-
-  /* function exit code */
-}
-
-/* "View.MemoryView":1371
- * 
- * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil')
- * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
- *                                              Py_ssize_t *strides, int ndim,
- *                                              bint inc) with gil:
- */
-
-static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) {
-  __Pyx_RefNannyDeclarations
-  #ifdef WITH_THREAD
-  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-  #endif
-  __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0);
-
-  /* "View.MemoryView":1374
- *                                              Py_ssize_t *strides, int ndim,
- *                                              bint inc) with gil:
- *     refcount_objects_in_slice(data, shape, strides, ndim, inc)             # <<<<<<<<<<<<<<
- * 
- * @cname('__pyx_memoryview_refcount_objects_in_slice')
- */
-  __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc);
-
-  /* "View.MemoryView":1371
- * 
- * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil')
- * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
- *                                              Py_ssize_t *strides, int ndim,
- *                                              bint inc) with gil:
- */
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  #ifdef WITH_THREAD
-  __Pyx_PyGILState_Release(__pyx_gilstate_save);
-  #endif
-}
-
-/* "View.MemoryView":1377
- * 
- * @cname('__pyx_memoryview_refcount_objects_in_slice')
- * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
- *                                     Py_ssize_t *strides, int ndim, bint inc):
- *     cdef Py_ssize_t i
- */
-
-static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) {
-  CYTHON_UNUSED Py_ssize_t __pyx_v_i;
-  __Pyx_RefNannyDeclarations
-  Py_ssize_t __pyx_t_1;
-  Py_ssize_t __pyx_t_2;
-  Py_ssize_t __pyx_t_3;
-  int __pyx_t_4;
-  __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0);
-
-  /* "View.MemoryView":1381
- *     cdef Py_ssize_t i
- * 
- *     for i in range(shape[0]):             # <<<<<<<<<<<<<<
- *         if ndim == 1:
- *             if inc:
- */
-  __pyx_t_1 = (__pyx_v_shape[0]);
-  __pyx_t_2 = __pyx_t_1;
-  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
-    __pyx_v_i = __pyx_t_3;
-
-    /* "View.MemoryView":1382
- * 
- *     for i in range(shape[0]):
- *         if ndim == 1:             # <<<<<<<<<<<<<<
- *             if inc:
- *                 Py_INCREF((<PyObject **> data)[0])
- */
-    __pyx_t_4 = ((__pyx_v_ndim == 1) != 0);
-    if (__pyx_t_4) {
-
-      /* "View.MemoryView":1383
- *     for i in range(shape[0]):
- *         if ndim == 1:
- *             if inc:             # <<<<<<<<<<<<<<
- *                 Py_INCREF((<PyObject **> data)[0])
- *             else:
- */
-      __pyx_t_4 = (__pyx_v_inc != 0);
-      if (__pyx_t_4) {
-
-        /* "View.MemoryView":1384
- *         if ndim == 1:
- *             if inc:
- *                 Py_INCREF((<PyObject **> data)[0])             # <<<<<<<<<<<<<<
- *             else:
- *                 Py_DECREF((<PyObject **> data)[0])
- */
-        Py_INCREF((((PyObject **)__pyx_v_data)[0]));
-
-        /* "View.MemoryView":1383
- *     for i in range(shape[0]):
- *         if ndim == 1:
- *             if inc:             # <<<<<<<<<<<<<<
- *                 Py_INCREF((<PyObject **> data)[0])
- *             else:
- */
-        goto __pyx_L6;
-      }
-
-      /* "View.MemoryView":1386
- *                 Py_INCREF((<PyObject **> data)[0])
- *             else:
- *                 Py_DECREF((<PyObject **> data)[0])             # <<<<<<<<<<<<<<
- *         else:
- *             refcount_objects_in_slice(data, shape + 1, strides + 1,
- */
-      /*else*/ {
-        Py_DECREF((((PyObject **)__pyx_v_data)[0]));
-      }
-      __pyx_L6:;
-
-      /* "View.MemoryView":1382
- * 
- *     for i in range(shape[0]):
- *         if ndim == 1:             # <<<<<<<<<<<<<<
- *             if inc:
- *                 Py_INCREF((<PyObject **> data)[0])
- */
-      goto __pyx_L5;
-    }
-
-    /* "View.MemoryView":1388
- *                 Py_DECREF((<PyObject **> data)[0])
- *         else:
- *             refcount_objects_in_slice(data, shape + 1, strides + 1,             # <<<<<<<<<<<<<<
- *                                       ndim - 1, inc)
- * 
- */
-    /*else*/ {
-
-      /* "View.MemoryView":1389
- *         else:
- *             refcount_objects_in_slice(data, shape + 1, strides + 1,
- *                                       ndim - 1, inc)             # <<<<<<<<<<<<<<
- * 
- *         data += strides[0]
- */
-      __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc);
-    }
-    __pyx_L5:;
-
-    /* "View.MemoryView":1391
- *                                       ndim - 1, inc)
- * 
- *         data += strides[0]             # <<<<<<<<<<<<<<
- * 
- * 
- */
-    __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0]));
-  }
-
-  /* "View.MemoryView":1377
- * 
- * @cname('__pyx_memoryview_refcount_objects_in_slice')
- * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
- *                                     Py_ssize_t *strides, int ndim, bint inc):
- *     cdef Py_ssize_t i
- */
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-/* "View.MemoryView":1397
- * 
- * @cname('__pyx_memoryview_slice_assign_scalar')
- * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim,             # <<<<<<<<<<<<<<
- *                               size_t itemsize, void *item,
- *                               bint dtype_is_object) nogil:
- */
-
-static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) {
-
-  /* "View.MemoryView":1400
- *                               size_t itemsize, void *item,
- *                               bint dtype_is_object) nogil:
- *     refcount_copying(dst, dtype_is_object, ndim, False)             # <<<<<<<<<<<<<<
- *     _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim,
- *                          itemsize, item)
- */
-  __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0);
-
-  /* "View.MemoryView":1401
- *                               bint dtype_is_object) nogil:
- *     refcount_copying(dst, dtype_is_object, ndim, False)
- *     _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim,             # <<<<<<<<<<<<<<
- *                          itemsize, item)
- *     refcount_copying(dst, dtype_is_object, ndim, True)
- */
-  __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item);
-
-  /* "View.MemoryView":1403
- *     _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim,
- *                          itemsize, item)
- *     refcount_copying(dst, dtype_is_object, ndim, True)             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1);
-
-  /* "View.MemoryView":1397
- * 
- * @cname('__pyx_memoryview_slice_assign_scalar')
- * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim,             # <<<<<<<<<<<<<<
- *                               size_t itemsize, void *item,
- *                               bint dtype_is_object) nogil:
- */
-
-  /* function exit code */
-}
-
-/* "View.MemoryView":1407
- * 
- * @cname('__pyx_memoryview__slice_assign_scalar')
- * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
- *                               Py_ssize_t *strides, int ndim,
- *                               size_t itemsize, void *item) nogil:
- */
-
-static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) {
-  CYTHON_UNUSED Py_ssize_t __pyx_v_i;
-  Py_ssize_t __pyx_v_stride;
-  Py_ssize_t __pyx_v_extent;
-  int __pyx_t_1;
-  Py_ssize_t __pyx_t_2;
-  Py_ssize_t __pyx_t_3;
-  Py_ssize_t __pyx_t_4;
-
-  /* "View.MemoryView":1411
- *                               size_t itemsize, void *item) nogil:
- *     cdef Py_ssize_t i
- *     cdef Py_ssize_t stride = strides[0]             # <<<<<<<<<<<<<<
- *     cdef Py_ssize_t extent = shape[0]
- * 
- */
-  __pyx_v_stride = (__pyx_v_strides[0]);
-
-  /* "View.MemoryView":1412
- *     cdef Py_ssize_t i
- *     cdef Py_ssize_t stride = strides[0]
- *     cdef Py_ssize_t extent = shape[0]             # <<<<<<<<<<<<<<
- * 
- *     if ndim == 1:
- */
-  __pyx_v_extent = (__pyx_v_shape[0]);
-
-  /* "View.MemoryView":1414
- *     cdef Py_ssize_t extent = shape[0]
- * 
- *     if ndim == 1:             # <<<<<<<<<<<<<<
- *         for i in range(extent):
- *             memcpy(data, item, itemsize)
- */
-  __pyx_t_1 = ((__pyx_v_ndim == 1) != 0);
-  if (__pyx_t_1) {
-
-    /* "View.MemoryView":1415
- * 
- *     if ndim == 1:
- *         for i in range(extent):             # <<<<<<<<<<<<<<
- *             memcpy(data, item, itemsize)
- *             data += stride
- */
-    __pyx_t_2 = __pyx_v_extent;
-    __pyx_t_3 = __pyx_t_2;
-    for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
-      __pyx_v_i = __pyx_t_4;
-
-      /* "View.MemoryView":1416
- *     if ndim == 1:
- *         for i in range(extent):
- *             memcpy(data, item, itemsize)             # <<<<<<<<<<<<<<
- *             data += stride
- *     else:
- */
-      (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize));
-
-      /* "View.MemoryView":1417
- *         for i in range(extent):
- *             memcpy(data, item, itemsize)
- *             data += stride             # <<<<<<<<<<<<<<
- *     else:
- *         for i in range(extent):
- */
-      __pyx_v_data = (__pyx_v_data + __pyx_v_stride);
-    }
-
-    /* "View.MemoryView":1414
- *     cdef Py_ssize_t extent = shape[0]
- * 
- *     if ndim == 1:             # <<<<<<<<<<<<<<
- *         for i in range(extent):
- *             memcpy(data, item, itemsize)
- */
-    goto __pyx_L3;
-  }
-
-  /* "View.MemoryView":1419
- *             data += stride
- *     else:
- *         for i in range(extent):             # <<<<<<<<<<<<<<
- *             _slice_assign_scalar(data, shape + 1, strides + 1,
- *                                 ndim - 1, itemsize, item)
- */
-  /*else*/ {
-    __pyx_t_2 = __pyx_v_extent;
-    __pyx_t_3 = __pyx_t_2;
-    for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
-      __pyx_v_i = __pyx_t_4;
-
-      /* "View.MemoryView":1420
- *     else:
- *         for i in range(extent):
- *             _slice_assign_scalar(data, shape + 1, strides + 1,             # <<<<<<<<<<<<<<
- *                                 ndim - 1, itemsize, item)
- *             data += stride
- */
-      __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item);
-
-      /* "View.MemoryView":1422
- *             _slice_assign_scalar(data, shape + 1, strides + 1,
- *                                 ndim - 1, itemsize, item)
- *             data += stride             # <<<<<<<<<<<<<<
- * 
- * 
- */
-      __pyx_v_data = (__pyx_v_data + __pyx_v_stride);
-    }
-  }
-  __pyx_L3:;
-
-  /* "View.MemoryView":1407
- * 
- * @cname('__pyx_memoryview__slice_assign_scalar')
- * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
- *                               Py_ssize_t *strides, int ndim,
- *                               size_t itemsize, void *item) nogil:
- */
-
-  /* function exit code */
-}
-
-/* "(tree fragment)":1
- * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
- *     cdef object __pyx_PickleError
- *     cdef object __pyx_result
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v___pyx_type = 0;
-  long __pyx_v___pyx_checksum;
-  PyObject *__pyx_v___pyx_state = 0;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0};
-    PyObject* values[3] = {0,0,0};
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
-      goto __pyx_L5_argtuple_error;
-    } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-    }
-    __pyx_v___pyx_type = values[0];
-    __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error)
-    __pyx_v___pyx_state = values[2];
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state);
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_v___pyx_PickleError = 0;
-  PyObject *__pyx_v___pyx_result = 0;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  int __pyx_t_6;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0);
-
-  /* "(tree fragment)":4
- *     cdef object __pyx_PickleError
- *     cdef object __pyx_result
- *     if __pyx_checksum != 0xb068931:             # <<<<<<<<<<<<<<
- *         from pickle import PickleError as __pyx_PickleError
- *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
- */
-  __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xb068931) != 0);
-  if (__pyx_t_1) {
-
-    /* "(tree fragment)":5
- *     cdef object __pyx_result
- *     if __pyx_checksum != 0xb068931:
- *         from pickle import PickleError as __pyx_PickleError             # <<<<<<<<<<<<<<
- *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
- *     __pyx_result = Enum.__new__(__pyx_type)
- */
-    __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_INCREF(__pyx_n_s_PickleError);
-    __Pyx_GIVEREF(__pyx_n_s_PickleError);
-    PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError);
-    __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_INCREF(__pyx_t_2);
-    __pyx_v___pyx_PickleError = __pyx_t_2;
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-    /* "(tree fragment)":6
- *     if __pyx_checksum != 0xb068931:
- *         from pickle import PickleError as __pyx_PickleError
- *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)             # <<<<<<<<<<<<<<
- *     __pyx_result = Enum.__new__(__pyx_type)
- *     if __pyx_state is not None:
- */
-    __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_INCREF(__pyx_v___pyx_PickleError);
-    __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
-      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
-      if (likely(__pyx_t_5)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-        __Pyx_INCREF(__pyx_t_5);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_2, function);
-      }
-    }
-    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(1, 6, __pyx_L1_error)
-
-    /* "(tree fragment)":4
- *     cdef object __pyx_PickleError
- *     cdef object __pyx_result
- *     if __pyx_checksum != 0xb068931:             # <<<<<<<<<<<<<<
- *         from pickle import PickleError as __pyx_PickleError
- *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
- */
-  }
-
-  /* "(tree fragment)":7
- *         from pickle import PickleError as __pyx_PickleError
- *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
- *     __pyx_result = Enum.__new__(__pyx_type)             # <<<<<<<<<<<<<<
- *     if __pyx_state is not None:
- *         __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
- */
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
-    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
-    if (likely(__pyx_t_4)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-      __Pyx_INCREF(__pyx_t_4);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_2, function);
-    }
-  }
-  __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v___pyx_result = __pyx_t_3;
-  __pyx_t_3 = 0;
-
-  /* "(tree fragment)":8
- *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
- *     __pyx_result = Enum.__new__(__pyx_type)
- *     if __pyx_state is not None:             # <<<<<<<<<<<<<<
- *         __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
- *     return __pyx_result
- */
-  __pyx_t_1 = (__pyx_v___pyx_state != Py_None);
-  __pyx_t_6 = (__pyx_t_1 != 0);
-  if (__pyx_t_6) {
-
-    /* "(tree fragment)":9
- *     __pyx_result = Enum.__new__(__pyx_type)
- *     if __pyx_state is not None:
- *         __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)             # <<<<<<<<<<<<<<
- *     return __pyx_result
- * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
- */
-    if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error)
-    __pyx_t_3 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-    /* "(tree fragment)":8
- *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
- *     __pyx_result = Enum.__new__(__pyx_type)
- *     if __pyx_state is not None:             # <<<<<<<<<<<<<<
- *         __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
- *     return __pyx_result
- */
-  }
-
-  /* "(tree fragment)":10
- *     if __pyx_state is not None:
- *         __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
- *     return __pyx_result             # <<<<<<<<<<<<<<
- * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
- *     __pyx_result.name = __pyx_state[0]
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v___pyx_result);
-  __pyx_r = __pyx_v___pyx_result;
-  goto __pyx_L0;
-
-  /* "(tree fragment)":1
- * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
- *     cdef object __pyx_PickleError
- *     cdef object __pyx_result
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v___pyx_PickleError);
-  __Pyx_XDECREF(__pyx_v___pyx_result);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "(tree fragment)":11
- *         __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
- *     return __pyx_result
- * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
- *     __pyx_result.name = __pyx_state[0]
- *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
- */
-
-static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_t_2;
-  Py_ssize_t __pyx_t_3;
-  int __pyx_t_4;
-  int __pyx_t_5;
-  PyObject *__pyx_t_6 = NULL;
-  PyObject *__pyx_t_7 = NULL;
-  PyObject *__pyx_t_8 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0);
-
-  /* "(tree fragment)":12
- *     return __pyx_result
- * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
- *     __pyx_result.name = __pyx_state[0]             # <<<<<<<<<<<<<<
- *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
- *         __pyx_result.__dict__.update(__pyx_state[1])
- */
-  if (unlikely(__pyx_v___pyx_state == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
-    __PYX_ERR(1, 12, __pyx_L1_error)
-  }
-  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_1);
-  __Pyx_GOTREF(__pyx_v___pyx_result->name);
-  __Pyx_DECREF(__pyx_v___pyx_result->name);
-  __pyx_v___pyx_result->name = __pyx_t_1;
-  __pyx_t_1 = 0;
-
-  /* "(tree fragment)":13
- * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
- *     __pyx_result.name = __pyx_state[0]
- *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):             # <<<<<<<<<<<<<<
- *         __pyx_result.__dict__.update(__pyx_state[1])
- */
-  if (unlikely(__pyx_v___pyx_state == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 13, __pyx_L1_error)
-  }
-  __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error)
-  __pyx_t_4 = ((__pyx_t_3 > 1) != 0);
-  if (__pyx_t_4) {
-  } else {
-    __pyx_t_2 = __pyx_t_4;
-    goto __pyx_L4_bool_binop_done;
-  }
-  __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error)
-  __pyx_t_5 = (__pyx_t_4 != 0);
-  __pyx_t_2 = __pyx_t_5;
-  __pyx_L4_bool_binop_done:;
-  if (__pyx_t_2) {
-
-    /* "(tree fragment)":14
- *     __pyx_result.name = __pyx_state[0]
- *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
- *         __pyx_result.__dict__.update(__pyx_state[1])             # <<<<<<<<<<<<<<
- */
-    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    if (unlikely(__pyx_v___pyx_state == Py_None)) {
-      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
-      __PYX_ERR(1, 14, __pyx_L1_error)
-    }
-    __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __pyx_t_8 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
-      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
-      if (likely(__pyx_t_8)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
-        __Pyx_INCREF(__pyx_t_8);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_7, function);
-      }
-    }
-    __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6);
-    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-    /* "(tree fragment)":13
- * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
- *     __pyx_result.name = __pyx_state[0]
- *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):             # <<<<<<<<<<<<<<
- *         __pyx_result.__dict__.update(__pyx_state[1])
- */
-  }
-
-  /* "(tree fragment)":11
- *         __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
- *     return __pyx_result
- * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
- *     __pyx_result.name = __pyx_state[0]
- *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
- */
-
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-static struct __pyx_vtabstruct_array __pyx_vtable_array;
-
-static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) {
-  struct __pyx_array_obj *p;
-  PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
-    o = (*t->tp_alloc)(t, 0);
-  } else {
-    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
-  }
-  if (unlikely(!o)) return 0;
-  p = ((struct __pyx_array_obj *)o);
-  p->__pyx_vtab = __pyx_vtabptr_array;
-  p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None);
-  p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None);
-  if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad;
-  return o;
-  bad:
-  Py_DECREF(o); o = 0;
-  return NULL;
-}
-
-static void __pyx_tp_dealloc_array(PyObject *o) {
-  struct __pyx_array_obj *p = (struct __pyx_array_obj *)o;
-  #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
-  }
-  #endif
-  {
-    PyObject *etype, *eval, *etb;
-    PyErr_Fetch(&etype, &eval, &etb);
-    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
-    __pyx_array___dealloc__(o);
-    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
-    PyErr_Restore(etype, eval, etb);
-  }
-  Py_CLEAR(p->mode);
-  Py_CLEAR(p->_format);
-  (*Py_TYPE(o)->tp_free)(o);
-}
-static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) {
-  PyObject *r;
-  PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
-  r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
-  Py_DECREF(x);
-  return r;
-}
-
-static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) {
-  if (v) {
-    return __pyx_array___setitem__(o, i, v);
-  }
-  else {
-    PyErr_Format(PyExc_NotImplementedError,
-      "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);
-    return -1;
-  }
-}
-
-static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) {
-  PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n);
-  if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) {
-    PyErr_Clear();
-    v = __pyx_array___getattr__(o, n);
-  }
-  return v;
-}
-
-static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o);
-}
-
-static PyMethodDef __pyx_methods_array[] = {
-  {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0},
-  {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0},
-  {0, 0, 0, 0}
-};
-
-static struct PyGetSetDef __pyx_getsets_array[] = {
-  {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0},
-  {0, 0, 0, 0, 0}
-};
-
-static PySequenceMethods __pyx_tp_as_sequence_array = {
-  __pyx_array___len__, /*sq_length*/
-  0, /*sq_concat*/
-  0, /*sq_repeat*/
-  __pyx_sq_item_array, /*sq_item*/
-  0, /*sq_slice*/
-  0, /*sq_ass_item*/
-  0, /*sq_ass_slice*/
-  0, /*sq_contains*/
-  0, /*sq_inplace_concat*/
-  0, /*sq_inplace_repeat*/
-};
-
-static PyMappingMethods __pyx_tp_as_mapping_array = {
-  __pyx_array___len__, /*mp_length*/
-  __pyx_array___getitem__, /*mp_subscript*/
-  __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/
-};
-
-static PyBufferProcs __pyx_tp_as_buffer_array = {
-  #if PY_MAJOR_VERSION < 3
-  0, /*bf_getreadbuffer*/
-  #endif
-  #if PY_MAJOR_VERSION < 3
-  0, /*bf_getwritebuffer*/
-  #endif
-  #if PY_MAJOR_VERSION < 3
-  0, /*bf_getsegcount*/
-  #endif
-  #if PY_MAJOR_VERSION < 3
-  0, /*bf_getcharbuffer*/
-  #endif
-  __pyx_array_getbuffer, /*bf_getbuffer*/
-  0, /*bf_releasebuffer*/
-};
-
-static PyTypeObject __pyx_type___pyx_array = {
-  PyVarObject_HEAD_INIT(0, 0)
-  "monotonic_align.core.array", /*tp_name*/
-  sizeof(struct __pyx_array_obj), /*tp_basicsize*/
-  0, /*tp_itemsize*/
-  __pyx_tp_dealloc_array, /*tp_dealloc*/
-  #if PY_VERSION_HEX < 0x030800b4
-  0, /*tp_print*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4
-  0, /*tp_vectorcall_offset*/
-  #endif
-  0, /*tp_getattr*/
-  0, /*tp_setattr*/
-  #if PY_MAJOR_VERSION < 3
-  0, /*tp_compare*/
-  #endif
-  #if PY_MAJOR_VERSION >= 3
-  0, /*tp_as_async*/
-  #endif
-  0, /*tp_repr*/
-  0, /*tp_as_number*/
-  &__pyx_tp_as_sequence_array, /*tp_as_sequence*/
-  &__pyx_tp_as_mapping_array, /*tp_as_mapping*/
-  0, /*tp_hash*/
-  0, /*tp_call*/
-  0, /*tp_str*/
-  __pyx_tp_getattro_array, /*tp_getattro*/
-  0, /*tp_setattro*/
-  &__pyx_tp_as_buffer_array, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
-  0, /*tp_doc*/
-  0, /*tp_traverse*/
-  0, /*tp_clear*/
-  0, /*tp_richcompare*/
-  0, /*tp_weaklistoffset*/
-  0, /*tp_iter*/
-  0, /*tp_iternext*/
-  __pyx_methods_array, /*tp_methods*/
-  0, /*tp_members*/
-  __pyx_getsets_array, /*tp_getset*/
-  0, /*tp_base*/
-  0, /*tp_dict*/
-  0, /*tp_descr_get*/
-  0, /*tp_descr_set*/
-  0, /*tp_dictoffset*/
-  0, /*tp_init*/
-  0, /*tp_alloc*/
-  __pyx_tp_new_array, /*tp_new*/
-  0, /*tp_free*/
-  0, /*tp_is_gc*/
-  0, /*tp_bases*/
-  0, /*tp_mro*/
-  0, /*tp_cache*/
-  0, /*tp_subclasses*/
-  0, /*tp_weaklist*/
-  0, /*tp_del*/
-  0, /*tp_version_tag*/
-  #if PY_VERSION_HEX >= 0x030400a1
-  0, /*tp_finalize*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b1
-  0, /*tp_vectorcall*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
-  0, /*tp_print*/
-  #endif
-};
-
-static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
-  struct __pyx_MemviewEnum_obj *p;
-  PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
-    o = (*t->tp_alloc)(t, 0);
-  } else {
-    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
-  }
-  if (unlikely(!o)) return 0;
-  p = ((struct __pyx_MemviewEnum_obj *)o);
-  p->name = Py_None; Py_INCREF(Py_None);
-  return o;
-}
-
-static void __pyx_tp_dealloc_Enum(PyObject *o) {
-  struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o;
-  #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
-  }
-  #endif
-  PyObject_GC_UnTrack(o);
-  Py_CLEAR(p->name);
-  (*Py_TYPE(o)->tp_free)(o);
-}
-
-static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) {
-  int e;
-  struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o;
-  if (p->name) {
-    e = (*v)(p->name, a); if (e) return e;
-  }
-  return 0;
-}
-
-static int __pyx_tp_clear_Enum(PyObject *o) {
-  PyObject* tmp;
-  struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o;
-  tmp = ((PyObject*)p->name);
-  p->name = Py_None; Py_INCREF(Py_None);
-  Py_XDECREF(tmp);
-  return 0;
-}
-
-static PyMethodDef __pyx_methods_Enum[] = {
-  {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0},
-  {0, 0, 0, 0}
-};
-
-static PyTypeObject __pyx_type___pyx_MemviewEnum = {
-  PyVarObject_HEAD_INIT(0, 0)
-  "monotonic_align.core.Enum", /*tp_name*/
-  sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/
-  0, /*tp_itemsize*/
-  __pyx_tp_dealloc_Enum, /*tp_dealloc*/
-  #if PY_VERSION_HEX < 0x030800b4
-  0, /*tp_print*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4
-  0, /*tp_vectorcall_offset*/
-  #endif
-  0, /*tp_getattr*/
-  0, /*tp_setattr*/
-  #if PY_MAJOR_VERSION < 3
-  0, /*tp_compare*/
-  #endif
-  #if PY_MAJOR_VERSION >= 3
-  0, /*tp_as_async*/
-  #endif
-  __pyx_MemviewEnum___repr__, /*tp_repr*/
-  0, /*tp_as_number*/
-  0, /*tp_as_sequence*/
-  0, /*tp_as_mapping*/
-  0, /*tp_hash*/
-  0, /*tp_call*/
-  0, /*tp_str*/
-  0, /*tp_getattro*/
-  0, /*tp_setattro*/
-  0, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  0, /*tp_doc*/
-  __pyx_tp_traverse_Enum, /*tp_traverse*/
-  __pyx_tp_clear_Enum, /*tp_clear*/
-  0, /*tp_richcompare*/
-  0, /*tp_weaklistoffset*/
-  0, /*tp_iter*/
-  0, /*tp_iternext*/
-  __pyx_methods_Enum, /*tp_methods*/
-  0, /*tp_members*/
-  0, /*tp_getset*/
-  0, /*tp_base*/
-  0, /*tp_dict*/
-  0, /*tp_descr_get*/
-  0, /*tp_descr_set*/
-  0, /*tp_dictoffset*/
-  __pyx_MemviewEnum___init__, /*tp_init*/
-  0, /*tp_alloc*/
-  __pyx_tp_new_Enum, /*tp_new*/
-  0, /*tp_free*/
-  0, /*tp_is_gc*/
-  0, /*tp_bases*/
-  0, /*tp_mro*/
-  0, /*tp_cache*/
-  0, /*tp_subclasses*/
-  0, /*tp_weaklist*/
-  0, /*tp_del*/
-  0, /*tp_version_tag*/
-  #if PY_VERSION_HEX >= 0x030400a1
-  0, /*tp_finalize*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b1
-  0, /*tp_vectorcall*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
-  0, /*tp_print*/
-  #endif
-};
-static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview;
-
-static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) {
-  struct __pyx_memoryview_obj *p;
-  PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
-    o = (*t->tp_alloc)(t, 0);
-  } else {
-    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
-  }
-  if (unlikely(!o)) return 0;
-  p = ((struct __pyx_memoryview_obj *)o);
-  p->__pyx_vtab = __pyx_vtabptr_memoryview;
-  p->obj = Py_None; Py_INCREF(Py_None);
-  p->_size = Py_None; Py_INCREF(Py_None);
-  p->_array_interface = Py_None; Py_INCREF(Py_None);
-  p->view.obj = NULL;
-  if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad;
-  return o;
-  bad:
-  Py_DECREF(o); o = 0;
-  return NULL;
-}
-
-static void __pyx_tp_dealloc_memoryview(PyObject *o) {
-  struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o;
-  #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
-  }
-  #endif
-  PyObject_GC_UnTrack(o);
-  {
-    PyObject *etype, *eval, *etb;
-    PyErr_Fetch(&etype, &eval, &etb);
-    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
-    __pyx_memoryview___dealloc__(o);
-    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
-    PyErr_Restore(etype, eval, etb);
-  }
-  Py_CLEAR(p->obj);
-  Py_CLEAR(p->_size);
-  Py_CLEAR(p->_array_interface);
-  (*Py_TYPE(o)->tp_free)(o);
-}
-
-static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) {
-  int e;
-  struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o;
-  if (p->obj) {
-    e = (*v)(p->obj, a); if (e) return e;
-  }
-  if (p->_size) {
-    e = (*v)(p->_size, a); if (e) return e;
-  }
-  if (p->_array_interface) {
-    e = (*v)(p->_array_interface, a); if (e) return e;
-  }
-  if (p->view.obj) {
-    e = (*v)(p->view.obj, a); if (e) return e;
-  }
-  return 0;
-}
-
-static int __pyx_tp_clear_memoryview(PyObject *o) {
-  PyObject* tmp;
-  struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o;
-  tmp = ((PyObject*)p->obj);
-  p->obj = Py_None; Py_INCREF(Py_None);
-  Py_XDECREF(tmp);
-  tmp = ((PyObject*)p->_size);
-  p->_size = Py_None; Py_INCREF(Py_None);
-  Py_XDECREF(tmp);
-  tmp = ((PyObject*)p->_array_interface);
-  p->_array_interface = Py_None; Py_INCREF(Py_None);
-  Py_XDECREF(tmp);
-  Py_CLEAR(p->view.obj);
-  return 0;
-}
-static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) {
-  PyObject *r;
-  PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
-  r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
-  Py_DECREF(x);
-  return r;
-}
-
-static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) {
-  if (v) {
-    return __pyx_memoryview___setitem__(o, i, v);
-  }
-  else {
-    PyErr_Format(PyExc_NotImplementedError,
-      "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);
-    return -1;
-  }
-}
-
-static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o);
-}
-
-static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o);
-}
-
-static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o);
-}
-
-static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o);
-}
-
-static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o);
-}
-
-static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o);
-}
-
-static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o);
-}
-
-static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o);
-}
-
-static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o);
-}
-
-static PyMethodDef __pyx_methods_memoryview[] = {
-  {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0},
-  {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0},
-  {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0},
-  {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0},
-  {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0},
-  {0, 0, 0, 0}
-};
-
-static struct PyGetSetDef __pyx_getsets_memoryview[] = {
-  {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0},
-  {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0},
-  {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0},
-  {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0},
-  {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0},
-  {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0},
-  {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0},
-  {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0},
-  {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0},
-  {0, 0, 0, 0, 0}
-};
-
-static PySequenceMethods __pyx_tp_as_sequence_memoryview = {
-  __pyx_memoryview___len__, /*sq_length*/
-  0, /*sq_concat*/
-  0, /*sq_repeat*/
-  __pyx_sq_item_memoryview, /*sq_item*/
-  0, /*sq_slice*/
-  0, /*sq_ass_item*/
-  0, /*sq_ass_slice*/
-  0, /*sq_contains*/
-  0, /*sq_inplace_concat*/
-  0, /*sq_inplace_repeat*/
-};
-
-static PyMappingMethods __pyx_tp_as_mapping_memoryview = {
-  __pyx_memoryview___len__, /*mp_length*/
-  __pyx_memoryview___getitem__, /*mp_subscript*/
-  __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/
-};
-
-static PyBufferProcs __pyx_tp_as_buffer_memoryview = {
-  #if PY_MAJOR_VERSION < 3
-  0, /*bf_getreadbuffer*/
-  #endif
-  #if PY_MAJOR_VERSION < 3
-  0, /*bf_getwritebuffer*/
-  #endif
-  #if PY_MAJOR_VERSION < 3
-  0, /*bf_getsegcount*/
-  #endif
-  #if PY_MAJOR_VERSION < 3
-  0, /*bf_getcharbuffer*/
-  #endif
-  __pyx_memoryview_getbuffer, /*bf_getbuffer*/
-  0, /*bf_releasebuffer*/
-};
-
-static PyTypeObject __pyx_type___pyx_memoryview = {
-  PyVarObject_HEAD_INIT(0, 0)
-  "monotonic_align.core.memoryview", /*tp_name*/
-  sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/
-  0, /*tp_itemsize*/
-  __pyx_tp_dealloc_memoryview, /*tp_dealloc*/
-  #if PY_VERSION_HEX < 0x030800b4
-  0, /*tp_print*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4
-  0, /*tp_vectorcall_offset*/
-  #endif
-  0, /*tp_getattr*/
-  0, /*tp_setattr*/
-  #if PY_MAJOR_VERSION < 3
-  0, /*tp_compare*/
-  #endif
-  #if PY_MAJOR_VERSION >= 3
-  0, /*tp_as_async*/
-  #endif
-  __pyx_memoryview___repr__, /*tp_repr*/
-  0, /*tp_as_number*/
-  &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/
-  &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/
-  0, /*tp_hash*/
-  0, /*tp_call*/
-  __pyx_memoryview___str__, /*tp_str*/
-  0, /*tp_getattro*/
-  0, /*tp_setattro*/
-  &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  0, /*tp_doc*/
-  __pyx_tp_traverse_memoryview, /*tp_traverse*/
-  __pyx_tp_clear_memoryview, /*tp_clear*/
-  0, /*tp_richcompare*/
-  0, /*tp_weaklistoffset*/
-  0, /*tp_iter*/
-  0, /*tp_iternext*/
-  __pyx_methods_memoryview, /*tp_methods*/
-  0, /*tp_members*/
-  __pyx_getsets_memoryview, /*tp_getset*/
-  0, /*tp_base*/
-  0, /*tp_dict*/
-  0, /*tp_descr_get*/
-  0, /*tp_descr_set*/
-  0, /*tp_dictoffset*/
-  0, /*tp_init*/
-  0, /*tp_alloc*/
-  __pyx_tp_new_memoryview, /*tp_new*/
-  0, /*tp_free*/
-  0, /*tp_is_gc*/
-  0, /*tp_bases*/
-  0, /*tp_mro*/
-  0, /*tp_cache*/
-  0, /*tp_subclasses*/
-  0, /*tp_weaklist*/
-  0, /*tp_del*/
-  0, /*tp_version_tag*/
-  #if PY_VERSION_HEX >= 0x030400a1
-  0, /*tp_finalize*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b1
-  0, /*tp_vectorcall*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
-  0, /*tp_print*/
-  #endif
-};
-static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice;
-
-static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) {
-  struct __pyx_memoryviewslice_obj *p;
-  PyObject *o = __pyx_tp_new_memoryview(t, a, k);
-  if (unlikely(!o)) return 0;
-  p = ((struct __pyx_memoryviewslice_obj *)o);
-  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice;
-  p->from_object = Py_None; Py_INCREF(Py_None);
-  p->from_slice.memview = NULL;
-  return o;
-}
-
-static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) {
-  struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o;
-  #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
-  }
-  #endif
-  PyObject_GC_UnTrack(o);
-  {
-    PyObject *etype, *eval, *etb;
-    PyErr_Fetch(&etype, &eval, &etb);
-    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
-    __pyx_memoryviewslice___dealloc__(o);
-    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
-    PyErr_Restore(etype, eval, etb);
-  }
-  Py_CLEAR(p->from_object);
-  PyObject_GC_Track(o);
-  __pyx_tp_dealloc_memoryview(o);
-}
-
-static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) {
-  int e;
-  struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o;
-  e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e;
-  if (p->from_object) {
-    e = (*v)(p->from_object, a); if (e) return e;
-  }
-  return 0;
-}
-
-static int __pyx_tp_clear__memoryviewslice(PyObject *o) {
-  PyObject* tmp;
-  struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o;
-  __pyx_tp_clear_memoryview(o);
-  tmp = ((PyObject*)p->from_object);
-  p->from_object = Py_None; Py_INCREF(Py_None);
-  Py_XDECREF(tmp);
-  __PYX_XDEC_MEMVIEW(&p->from_slice, 1);
-  return 0;
-}
-
-static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o);
-}
-
-static PyMethodDef __pyx_methods__memoryviewslice[] = {
-  {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0},
-  {0, 0, 0, 0}
-};
-
-static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = {
-  {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0},
-  {0, 0, 0, 0, 0}
-};
-
-static PyTypeObject __pyx_type___pyx_memoryviewslice = {
-  PyVarObject_HEAD_INIT(0, 0)
-  "monotonic_align.core._memoryviewslice", /*tp_name*/
-  sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/
-  0, /*tp_itemsize*/
-  __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/
-  #if PY_VERSION_HEX < 0x030800b4
-  0, /*tp_print*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4
-  0, /*tp_vectorcall_offset*/
-  #endif
-  0, /*tp_getattr*/
-  0, /*tp_setattr*/
-  #if PY_MAJOR_VERSION < 3
-  0, /*tp_compare*/
-  #endif
-  #if PY_MAJOR_VERSION >= 3
-  0, /*tp_as_async*/
-  #endif
-  #if CYTHON_COMPILING_IN_PYPY
-  __pyx_memoryview___repr__, /*tp_repr*/
-  #else
-  0, /*tp_repr*/
-  #endif
-  0, /*tp_as_number*/
-  0, /*tp_as_sequence*/
-  0, /*tp_as_mapping*/
-  0, /*tp_hash*/
-  0, /*tp_call*/
-  #if CYTHON_COMPILING_IN_PYPY
-  __pyx_memoryview___str__, /*tp_str*/
-  #else
-  0, /*tp_str*/
-  #endif
-  0, /*tp_getattro*/
-  0, /*tp_setattro*/
-  0, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  "Internal class for passing memoryview slices to Python", /*tp_doc*/
-  __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/
-  __pyx_tp_clear__memoryviewslice, /*tp_clear*/
-  0, /*tp_richcompare*/
-  0, /*tp_weaklistoffset*/
-  0, /*tp_iter*/
-  0, /*tp_iternext*/
-  __pyx_methods__memoryviewslice, /*tp_methods*/
-  0, /*tp_members*/
-  __pyx_getsets__memoryviewslice, /*tp_getset*/
-  0, /*tp_base*/
-  0, /*tp_dict*/
-  0, /*tp_descr_get*/
-  0, /*tp_descr_set*/
-  0, /*tp_dictoffset*/
-  0, /*tp_init*/
-  0, /*tp_alloc*/
-  __pyx_tp_new__memoryviewslice, /*tp_new*/
-  0, /*tp_free*/
-  0, /*tp_is_gc*/
-  0, /*tp_bases*/
-  0, /*tp_mro*/
-  0, /*tp_cache*/
-  0, /*tp_subclasses*/
-  0, /*tp_weaklist*/
-  0, /*tp_del*/
-  0, /*tp_version_tag*/
-  #if PY_VERSION_HEX >= 0x030400a1
-  0, /*tp_finalize*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b1
-  0, /*tp_vectorcall*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
-  0, /*tp_print*/
-  #endif
-};
-
-static PyMethodDef __pyx_methods[] = {
-  {"maximum_path_c", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_15monotonic_align_4core_1maximum_path_c, METH_VARARGS|METH_KEYWORDS, 0},
-  {0, 0, 0, 0}
-};
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_core(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_core},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "core",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
-#ifndef CYTHON_SMALL_CODE
-#if defined(__clang__)
-    #define CYTHON_SMALL_CODE
-#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-    #define CYTHON_SMALL_CODE __attribute__((cold))
-#else
-    #define CYTHON_SMALL_CODE
-#endif
-#endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1},
-  {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0},
-  {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0},
-  {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0},
-  {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0},
-  {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0},
-  {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1},
-  {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0},
-  {&__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_k_Incompatible_checksums_s_vs_0xb0, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xb0), 0, 0, 1, 0},
-  {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0},
-  {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0},
-  {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0},
-  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
-  {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0},
-  {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0},
-  {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1},
-  {&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0},
-  {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0},
-  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
-  {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1},
-  {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1},
-  {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1},
-  {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1},
-  {&__pyx_n_u_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 1, 0, 1},
-  {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_kp_s_contiguous_and_direct, __pyx_k_contiguous_and_direct, sizeof(__pyx_k_contiguous_and_direct), 0, 0, 1, 0},
-  {&__pyx_kp_s_contiguous_and_indirect, __pyx_k_contiguous_and_indirect, sizeof(__pyx_k_contiguous_and_indirect), 0, 0, 1, 0},
-  {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1},
-  {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1},
-  {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1},
-  {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1},
-  {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1},
-  {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1},
-  {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1},
-  {&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1},
-  {&__pyx_n_u_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 1, 0, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 0, 1, 0},
-  {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1},
-  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
-  {&__pyx_n_s_itemsize, __pyx_k_itemsize, sizeof(__pyx_k_itemsize), 0, 0, 1, 1},
-  {&__pyx_kp_s_itemsize_0_for_cython_array, __pyx_k_itemsize_0_for_cython_array, sizeof(__pyx_k_itemsize_0_for_cython_array), 0, 0, 1, 0},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1},
-  {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1},
-  {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1},
-  {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1},
-  {&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1},
-  {&__pyx_n_s_paths, __pyx_k_paths, sizeof(__pyx_k_paths), 0, 0, 1, 1},
-  {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1},
-  {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1},
-  {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1},
-  {&__pyx_n_s_pyx_getbuffer, __pyx_k_pyx_getbuffer, sizeof(__pyx_k_pyx_getbuffer), 0, 0, 1, 1},
-  {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1},
-  {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
-  {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1},
-  {&__pyx_n_s_pyx_unpickle_Enum, __pyx_k_pyx_unpickle_Enum, sizeof(__pyx_k_pyx_unpickle_Enum), 0, 0, 1, 1},
-  {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1},
-  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1},
-  {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
-  {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1},
-  {&__pyx_n_s_step, __pyx_k_step, sizeof(__pyx_k_step), 0, 0, 1, 1},
-  {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1},
-  {&__pyx_kp_s_strided_and_direct, __pyx_k_strided_and_direct, sizeof(__pyx_k_strided_and_direct), 0, 0, 1, 0},
-  {&__pyx_kp_s_strided_and_direct_or_indirect, __pyx_k_strided_and_direct_or_indirect, sizeof(__pyx_k_strided_and_direct_or_indirect), 0, 0, 1, 0},
-  {&__pyx_kp_s_strided_and_indirect, __pyx_k_strided_and_indirect, sizeof(__pyx_k_strided_and_indirect), 0, 0, 1, 0},
-  {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
-  {&__pyx_n_s_struct, __pyx_k_struct, sizeof(__pyx_k_struct), 0, 0, 1, 1},
-  {&__pyx_n_s_t_xs, __pyx_k_t_xs, sizeof(__pyx_k_t_xs), 0, 0, 1, 1},
-  {&__pyx_n_s_t_ys, __pyx_k_t_ys, sizeof(__pyx_k_t_ys), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {&__pyx_kp_s_unable_to_allocate_array_data, __pyx_k_unable_to_allocate_array_data, sizeof(__pyx_k_unable_to_allocate_array_data), 0, 0, 1, 0},
-  {&__pyx_kp_s_unable_to_allocate_shape_and_str, __pyx_k_unable_to_allocate_shape_and_str, sizeof(__pyx_k_unable_to_allocate_shape_and_str), 0, 0, 1, 0},
-  {&__pyx_n_s_unpack, __pyx_k_unpack, sizeof(__pyx_k_unpack), 0, 0, 1, 1},
-  {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1},
-  {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
-static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
-  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 15, __pyx_L1_error)
-  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 133, __pyx_L1_error)
-  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 148, __pyx_L1_error)
-  __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 151, __pyx_L1_error)
-  __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error)
-  __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 404, __pyx_L1_error)
-  __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 613, __pyx_L1_error)
-  __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 832, __pyx_L1_error)
-  return 0;
-  __pyx_L1_error:;
-  return -1;
-}
-
-static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
-
-  /* "View.MemoryView":133
- * 
- *         if not self.ndim:
- *             raise ValueError("Empty shape tuple for cython.array")             # <<<<<<<<<<<<<<
- * 
- *         if itemsize <= 0:
- */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 133, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
-
-  /* "View.MemoryView":136
- * 
- *         if itemsize <= 0:
- *             raise ValueError("itemsize <= 0 for cython.array")             # <<<<<<<<<<<<<<
- * 
- *         if not isinstance(format, bytes):
- */
-  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 136, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__3);
-  __Pyx_GIVEREF(__pyx_tuple__3);
-
-  /* "View.MemoryView":148
- * 
- *         if not self._shape:
- *             raise MemoryError("unable to allocate shape and strides.")             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 148, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__4);
-  __Pyx_GIVEREF(__pyx_tuple__4);
-
-  /* "View.MemoryView":176
- *             self.data = <char *>malloc(self.len)
- *             if not self.data:
- *                 raise MemoryError("unable to allocate array data.")             # <<<<<<<<<<<<<<
- * 
- *             if self.dtype_is_object:
- */
-  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 176, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__5);
-  __Pyx_GIVEREF(__pyx_tuple__5);
-
-  /* "View.MemoryView":192
- *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- *         if not (flags & bufmode):
- *             raise ValueError("Can only create a buffer that is contiguous in memory.")             # <<<<<<<<<<<<<<
- *         info.buf = self.data
- *         info.len = self.len
- */
-  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 192, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__6);
-  __Pyx_GIVEREF(__pyx_tuple__6);
-
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__7);
-  __Pyx_GIVEREF(__pyx_tuple__7);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__8);
-  __Pyx_GIVEREF(__pyx_tuple__8);
-
-  /* "View.MemoryView":418
- *     def __setitem__(memoryview self, object index, object value):
- *         if self.view.readonly:
- *             raise TypeError("Cannot assign to read-only memoryview")             # <<<<<<<<<<<<<<
- * 
- *         have_slices, index = _unellipsify(index, self.view.ndim)
- */
-  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 418, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__9);
-  __Pyx_GIVEREF(__pyx_tuple__9);
-
-  /* "View.MemoryView":495
- *             result = struct.unpack(self.view.format, bytesitem)
- *         except struct.error:
- *             raise ValueError("Unable to convert item to object")             # <<<<<<<<<<<<<<
- *         else:
- *             if len(self.view.format) == 1:
- */
-  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 495, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__10);
-  __Pyx_GIVEREF(__pyx_tuple__10);
-
-  /* "View.MemoryView":520
- *     def __getbuffer__(self, Py_buffer *info, int flags):
- *         if flags & PyBUF_WRITABLE and self.view.readonly:
- *             raise ValueError("Cannot create writable memory view from read-only memoryview")             # <<<<<<<<<<<<<<
- * 
- *         if flags & PyBUF_ND:
- */
-  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 520, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__11);
-  __Pyx_GIVEREF(__pyx_tuple__11);
-
-  /* "View.MemoryView":570
- *         if self.view.strides == NULL:
- * 
- *             raise ValueError("Buffer view does not expose strides")             # <<<<<<<<<<<<<<
- * 
- *         return tuple([stride for stride in self.view.strides[:self.view.ndim]])
- */
-  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 570, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__12);
-  __Pyx_GIVEREF(__pyx_tuple__12);
-
-  /* "View.MemoryView":577
- *     def suboffsets(self):
- *         if self.view.suboffsets == NULL:
- *             return (-1,) * self.view.ndim             # <<<<<<<<<<<<<<
- * 
- *         return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
- */
-  __pyx_tuple__13 = PyTuple_New(1); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 577, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__13);
-  __Pyx_INCREF(__pyx_int_neg_1);
-  __Pyx_GIVEREF(__pyx_int_neg_1);
-  PyTuple_SET_ITEM(__pyx_tuple__13, 0, __pyx_int_neg_1);
-  __Pyx_GIVEREF(__pyx_tuple__13);
-
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__14);
-  __Pyx_GIVEREF(__pyx_tuple__14);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__15);
-  __Pyx_GIVEREF(__pyx_tuple__15);
-
-  /* "View.MemoryView":682
- *         if item is Ellipsis:
- *             if not seen_ellipsis:
- *                 result.extend([slice(None)] * (ndim - len(tup) + 1))             # <<<<<<<<<<<<<<
- *                 seen_ellipsis = True
- *             else:
- */
-  __pyx_slice__16 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__16)) __PYX_ERR(1, 682, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_slice__16);
-  __Pyx_GIVEREF(__pyx_slice__16);
-
-  /* "View.MemoryView":703
- *     for suboffset in suboffsets[:ndim]:
- *         if suboffset >= 0:
- *             raise ValueError("Indirect dimensions not supported")             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 703, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__17);
-  __Pyx_GIVEREF(__pyx_tuple__17);
-
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-  __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__18);
-  __Pyx_GIVEREF(__pyx_tuple__18);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__19);
-  __Pyx_GIVEREF(__pyx_tuple__19);
-
-  /* "View.MemoryView":286
- *         return self.name
- * 
- * cdef generic = Enum("<strided and direct or indirect>")             # <<<<<<<<<<<<<<
- * cdef strided = Enum("<strided and direct>") # default
- * cdef indirect = Enum("<strided and indirect>")
- */
-  __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 286, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__20);
-  __Pyx_GIVEREF(__pyx_tuple__20);
-
-  /* "View.MemoryView":287
- * 
- * cdef generic = Enum("<strided and direct or indirect>")
- * cdef strided = Enum("<strided and direct>") # default             # <<<<<<<<<<<<<<
- * cdef indirect = Enum("<strided and indirect>")
- * 
- */
-  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 287, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__21);
-  __Pyx_GIVEREF(__pyx_tuple__21);
-
-  /* "View.MemoryView":288
- * cdef generic = Enum("<strided and direct or indirect>")
- * cdef strided = Enum("<strided and direct>") # default
- * cdef indirect = Enum("<strided and indirect>")             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 288, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__22);
-  __Pyx_GIVEREF(__pyx_tuple__22);
-
-  /* "View.MemoryView":291
- * 
- * 
- * cdef contiguous = Enum("<contiguous and direct>")             # <<<<<<<<<<<<<<
- * cdef indirect_contiguous = Enum("<contiguous and indirect>")
- * 
- */
-  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 291, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__23);
-  __Pyx_GIVEREF(__pyx_tuple__23);
-
-  /* "View.MemoryView":292
- * 
- * cdef contiguous = Enum("<contiguous and direct>")
- * cdef indirect_contiguous = Enum("<contiguous and indirect>")             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 292, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__24);
-  __Pyx_GIVEREF(__pyx_tuple__24);
-
-  /* "(tree fragment)":1
- * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
- *     cdef object __pyx_PickleError
- *     cdef object __pyx_result
- */
-  __pyx_tuple__25 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__25);
-  __Pyx_GIVEREF(__pyx_tuple__25);
-  __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
-
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  /* InitThreads.init */
-  #ifdef WITH_THREAD
-PyEval_InitThreads();
-#endif
-
-if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)
-
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
-  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  return 0;
-  __pyx_L1_error:;
-  return -1;
-}
-
-static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
-
-static int __Pyx_modinit_global_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
-  /*--- Global init code ---*/
-  generic = Py_None; Py_INCREF(Py_None);
-  strided = Py_None; Py_INCREF(Py_None);
-  indirect = Py_None; Py_INCREF(Py_None);
-  contiguous = Py_None; Py_INCREF(Py_None);
-  indirect_contiguous = Py_None; Py_INCREF(Py_None);
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
-
-static int __Pyx_modinit_variable_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
-  /*--- Variable export code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
-
-static int __Pyx_modinit_function_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
-  /*--- Function export code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
-
-static int __Pyx_modinit_type_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
-  /*--- Type init code ---*/
-  __pyx_vtabptr_array = &__pyx_vtable_array;
-  __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview;
-  if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 105, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type___pyx_array.tp_print = 0;
-  #endif
-  if (__Pyx_SetVtable(__pyx_type___pyx_array.tp_dict, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 105, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 105, __pyx_L1_error)
-  __pyx_array_type = &__pyx_type___pyx_array;
-  if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 279, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type___pyx_MemviewEnum.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_MemviewEnum.tp_dictoffset && __pyx_type___pyx_MemviewEnum.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type___pyx_MemviewEnum.tp_getattro = __Pyx_PyObject_GenericGetAttr;
-  }
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 279, __pyx_L1_error)
-  __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum;
-  __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview;
-  __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer;
-  __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice;
-  __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment;
-  __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar;
-  __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed;
-  __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object;
-  __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object;
-  if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 330, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type___pyx_memoryview.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryview.tp_dictoffset && __pyx_type___pyx_memoryview.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type___pyx_memoryview.tp_getattro = __Pyx_PyObject_GenericGetAttr;
-  }
-  if (__Pyx_SetVtable(__pyx_type___pyx_memoryview.tp_dict, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 330, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 330, __pyx_L1_error)
-  __pyx_memoryview_type = &__pyx_type___pyx_memoryview;
-  __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice;
-  __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview;
-  __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object;
-  __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object;
-  __pyx_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type;
-  if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 965, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type___pyx_memoryviewslice.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr;
-  }
-  if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 965, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 965, __pyx_L1_error)
-  __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
-
-static int __Pyx_modinit_type_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
-  /*--- Type import code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
-
-static int __Pyx_modinit_variable_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
-  /*--- Variable import code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
-
-static int __Pyx_modinit_function_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
-  /*--- Function import code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
-
-
-#ifndef CYTHON_NO_PYINIT_EXPORT
-#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
-#elif PY_MAJOR_VERSION < 3
-#ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" void
-#else
-#define __Pyx_PyMODINIT_FUNC void
-#endif
-#else
-#ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
-#else
-#define __Pyx_PyMODINIT_FUNC PyObject *
-#endif
-#endif
-
-
-#if PY_MAJOR_VERSION < 3
-__Pyx_PyMODINIT_FUNC initcore(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC initcore(void)
-#else
-__Pyx_PyMODINIT_FUNC PyInit_core(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC PyInit_core(void)
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-{
-  return PyModuleDef_Init(&__pyx_moduledef);
-}
-static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
-    #if PY_VERSION_HEX >= 0x030700A1
-    static PY_INT64_T main_interpreter_id = -1;
-    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
-    if (main_interpreter_id == -1) {
-        main_interpreter_id = current_id;
-        return (unlikely(current_id == -1)) ? -1 : 0;
-    } else if (unlikely(main_interpreter_id != current_id))
-    #else
-    static PyInterpreterState *main_interpreter = NULL;
-    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
-    if (!main_interpreter) {
-        main_interpreter = current_interpreter;
-    } else if (unlikely(main_interpreter != current_interpreter))
-    #endif
-    {
-        PyErr_SetString(
-            PyExc_ImportError,
-            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
-        return -1;
-    }
-    return 0;
-}
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
-    PyObject *value = PyObject_GetAttrString(spec, from_name);
-    int result = 0;
-    if (likely(value)) {
-        if (allow_none || value != Py_None) {
-            result = PyDict_SetItemString(moddict, to_name, value);
-        }
-        Py_DECREF(value);
-    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
-        PyErr_Clear();
-    } else {
-        result = -1;
-    }
-    return result;
-}
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
-    PyObject *module = NULL, *moddict, *modname;
-    if (__Pyx_check_single_interpreter())
-        return NULL;
-    if (__pyx_m)
-        return __Pyx_NewRef(__pyx_m);
-    modname = PyObject_GetAttrString(spec, "name");
-    if (unlikely(!modname)) goto bad;
-    module = PyModule_NewObject(modname);
-    Py_DECREF(modname);
-    if (unlikely(!module)) goto bad;
-    moddict = PyModule_GetDict(module);
-    if (unlikely(!moddict)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
-    return module;
-bad:
-    Py_XDECREF(module);
-    return NULL;
-}
-
-
-static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module)
-#endif
-#endif
-{
-  PyObject *__pyx_t_1 = NULL;
-  static PyThread_type_lock __pyx_t_2[8];
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannyDeclarations
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  if (__pyx_m) {
-    if (__pyx_m == __pyx_pyinit_module) return 0;
-    PyErr_SetString(PyExc_RuntimeError, "Module 'core' has already been imported. Re-initialisation is not supported.");
-    return -1;
-  }
-  #elif PY_MAJOR_VERSION >= 3
-  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
-  #endif
-  #if CYTHON_REFNANNY
-__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
-if (!__Pyx_RefNanny) {
-  PyErr_Clear();
-  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
-  if (!__Pyx_RefNanny)
-      Py_FatalError("failed to import 'refnanny' module");
-}
-#endif
-  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_core(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #ifdef __Pxy_PyFrame_Initialize_Offsets
-  __Pxy_PyFrame_Initialize_Offsets();
-  #endif
-  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  /*--- Library function declarations ---*/
-  /*--- Threads initialization code ---*/
-  #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
-  #ifdef WITH_THREAD /* Python build with threading support? */
-  PyEval_InitThreads();
-  #endif
-  #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("core", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
-  /*--- Initialize various global constants etc. ---*/
-  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
-  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  if (__pyx_module_is_main_monotonic_align__core) {
-    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  }
-  #if PY_MAJOR_VERSION >= 3
-  {
-    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
-    if (!PyDict_GetItemString(modules, "monotonic_align.core")) {
-      if (unlikely(PyDict_SetItemString(modules, "monotonic_align.core", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-    }
-  }
-  #endif
-  /*--- Builtin init code ---*/
-  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  /*--- Constants init code ---*/
-  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  /*--- Global type/function init code ---*/
-  (void)__Pyx_modinit_global_init_code();
-  (void)__Pyx_modinit_variable_export_code();
-  (void)__Pyx_modinit_function_export_code();
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  (void)__Pyx_modinit_type_import_code();
-  (void)__Pyx_modinit_variable_import_code();
-  (void)__Pyx_modinit_function_import_code();
-  /*--- Execution code ---*/
-  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
-  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-
-  /* "monotonic_align/core.pyx":7
- * @cython.boundscheck(False)
- * @cython.wraparound(False)
- * cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_y, int t_x, float max_neg_val=-1e9) nogil:             # <<<<<<<<<<<<<<
- *   cdef int x
- *   cdef int y
- */
-  __pyx_k_ = (-1e9);
-
-  /* "monotonic_align/core.pyx":1
- * cimport cython             # <<<<<<<<<<<<<<
- * from cython.parallel import prange
- * 
- */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  /* "View.MemoryView":209
- *         info.obj = self
- * 
- *     __pyx_getbuffer = capsule(<void *> &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")             # <<<<<<<<<<<<<<
- * 
- *     def __dealloc__(array self):
- */
-  __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 209, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 209, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  PyType_Modified(__pyx_array_type);
-
-  /* "View.MemoryView":286
- *         return self.name
- * 
- * cdef generic = Enum("<strided and direct or indirect>")             # <<<<<<<<<<<<<<
- * cdef strided = Enum("<strided and direct>") # default
- * cdef indirect = Enum("<strided and indirect>")
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 286, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_XGOTREF(generic);
-  __Pyx_DECREF_SET(generic, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  /* "View.MemoryView":287
- * 
- * cdef generic = Enum("<strided and direct or indirect>")
- * cdef strided = Enum("<strided and direct>") # default             # <<<<<<<<<<<<<<
- * cdef indirect = Enum("<strided and indirect>")
- * 
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 287, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_XGOTREF(strided);
-  __Pyx_DECREF_SET(strided, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  /* "View.MemoryView":288
- * cdef generic = Enum("<strided and direct or indirect>")
- * cdef strided = Enum("<strided and direct>") # default
- * cdef indirect = Enum("<strided and indirect>")             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 288, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_XGOTREF(indirect);
-  __Pyx_DECREF_SET(indirect, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  /* "View.MemoryView":291
- * 
- * 
- * cdef contiguous = Enum("<contiguous and direct>")             # <<<<<<<<<<<<<<
- * cdef indirect_contiguous = Enum("<contiguous and indirect>")
- * 
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 291, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_XGOTREF(contiguous);
-  __Pyx_DECREF_SET(contiguous, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  /* "View.MemoryView":292
- * 
- * cdef contiguous = Enum("<contiguous and direct>")
- * cdef indirect_contiguous = Enum("<contiguous and indirect>")             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 292, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_XGOTREF(indirect_contiguous);
-  __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  /* "View.MemoryView":316
- * 
- * DEF THREAD_LOCKS_PREALLOCATED = 8
- * cdef int __pyx_memoryview_thread_locks_used = 0             # <<<<<<<<<<<<<<
- * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [
- *     PyThread_allocate_lock(),
- */
-  __pyx_memoryview_thread_locks_used = 0;
-
-  /* "View.MemoryView":317
- * DEF THREAD_LOCKS_PREALLOCATED = 8
- * cdef int __pyx_memoryview_thread_locks_used = 0
- * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [             # <<<<<<<<<<<<<<
- *     PyThread_allocate_lock(),
- *     PyThread_allocate_lock(),
- */
-  __pyx_t_2[0] = PyThread_allocate_lock();
-  __pyx_t_2[1] = PyThread_allocate_lock();
-  __pyx_t_2[2] = PyThread_allocate_lock();
-  __pyx_t_2[3] = PyThread_allocate_lock();
-  __pyx_t_2[4] = PyThread_allocate_lock();
-  __pyx_t_2[5] = PyThread_allocate_lock();
-  __pyx_t_2[6] = PyThread_allocate_lock();
-  __pyx_t_2[7] = PyThread_allocate_lock();
-  memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_2, sizeof(__pyx_memoryview_thread_locks[0]) * (8));
-
-  /* "View.MemoryView":549
- *         info.obj = self
- * 
- *     __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 549, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 549, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  PyType_Modified(__pyx_memoryview_type);
-
-  /* "View.MemoryView":995
- *         return self.from_object
- * 
- *     __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 995, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 995, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  PyType_Modified(__pyx_memoryviewslice_type);
-
-  /* "(tree fragment)":1
- * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
- *     cdef object __pyx_PickleError
- *     cdef object __pyx_result
- */
-  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  /* "(tree fragment)":11
- *         __pyx_unpickle_Enum__set_state(<Enum> __pyx_result, __pyx_state)
- *     return __pyx_result
- * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
- *     __pyx_result.name = __pyx_state[0]
- *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
- */
-
-  /*--- Wrapped vars code ---*/
-
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  if (__pyx_m) {
-    if (__pyx_d) {
-      __Pyx_AddTraceback("init monotonic_align.core", __pyx_clineno, __pyx_lineno, __pyx_filename);
-    }
-    Py_CLEAR(__pyx_m);
-  } else if (!PyErr_Occurred()) {
-    PyErr_SetString(PyExc_ImportError, "init monotonic_align.core");
-  }
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  return (__pyx_m != NULL) ? 0 : -1;
-  #elif PY_MAJOR_VERSION >= 3
-  return __pyx_m;
-  #else
-  return;
-  #endif
-}
-
-/* --- Runtime support code --- */
-/* Refnanny */
-#if CYTHON_REFNANNY
-static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
-    PyObject *m = NULL, *p = NULL;
-    void *r = NULL;
-    m = PyImport_ImportModule(modname);
-    if (!m) goto end;
-    p = PyObject_GetAttrString(m, "RefNannyAPI");
-    if (!p) goto end;
-    r = PyLong_AsVoidPtr(p);
-end:
-    Py_XDECREF(p);
-    Py_XDECREF(m);
-    return (__Pyx_RefNannyAPIStruct *)r;
-}
-#endif
-
-/* PyObjectGetAttrStr */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro))
-        return tp->tp_getattro(obj, attr_name);
-#if PY_MAJOR_VERSION < 3
-    if (likely(tp->tp_getattr))
-        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
-#endif
-    return PyObject_GetAttr(obj, attr_name);
-}
-#endif
-
-/* GetBuiltinName */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
-        PyErr_Format(PyExc_NameError,
-#if PY_MAJOR_VERSION >= 3
-            "name '%U' is not defined", name);
-#else
-            "name '%.200s' is not defined", PyString_AS_STRING(name));
-#endif
-    }
-    return result;
-}
-
-/* MemviewSliceInit */
-static int
-__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview,
-                        int ndim,
-                        __Pyx_memviewslice *memviewslice,
-                        int memview_is_new_reference)
-{
-    __Pyx_RefNannyDeclarations
-    int i, retval=-1;
-    Py_buffer *buf = &memview->view;
-    __Pyx_RefNannySetupContext("init_memviewslice", 0);
-    if (unlikely(memviewslice->memview || memviewslice->data)) {
-        PyErr_SetString(PyExc_ValueError,
-            "memviewslice is already initialized!");
-        goto fail;
-    }
-    if (buf->strides) {
-        for (i = 0; i < ndim; i++) {
-            memviewslice->strides[i] = buf->strides[i];
-        }
-    } else {
-        Py_ssize_t stride = buf->itemsize;
-        for (i = ndim - 1; i >= 0; i--) {
-            memviewslice->strides[i] = stride;
-            stride *= buf->shape[i];
-        }
-    }
-    for (i = 0; i < ndim; i++) {
-        memviewslice->shape[i]   = buf->shape[i];
-        if (buf->suboffsets) {
-            memviewslice->suboffsets[i] = buf->suboffsets[i];
-        } else {
-            memviewslice->suboffsets[i] = -1;
-        }
-    }
-    memviewslice->memview = memview;
-    memviewslice->data = (char *)buf->buf;
-    if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) {
-        Py_INCREF(memview);
-    }
-    retval = 0;
-    goto no_fail;
-fail:
-    memviewslice->memview = 0;
-    memviewslice->data = 0;
-    retval = -1;
-no_fail:
-    __Pyx_RefNannyFinishContext();
-    return retval;
-}
-#ifndef Py_NO_RETURN
-#define Py_NO_RETURN
-#endif
-static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN {
-    va_list vargs;
-    char msg[200];
-#ifdef HAVE_STDARG_PROTOTYPES
-    va_start(vargs, fmt);
-#else
-    va_start(vargs);
-#endif
-    vsnprintf(msg, 200, fmt, vargs);
-    va_end(vargs);
-    Py_FatalError(msg);
-}
-static CYTHON_INLINE int
-__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count,
-                                   PyThread_type_lock lock)
-{
-    int result;
-    PyThread_acquire_lock(lock, 1);
-    result = (*acquisition_count)++;
-    PyThread_release_lock(lock);
-    return result;
-}
-static CYTHON_INLINE int
-__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count,
-                                   PyThread_type_lock lock)
-{
-    int result;
-    PyThread_acquire_lock(lock, 1);
-    result = (*acquisition_count)--;
-    PyThread_release_lock(lock);
-    return result;
-}
-static CYTHON_INLINE void
-__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno)
-{
-    int first_time;
-    struct __pyx_memoryview_obj *memview = memslice->memview;
-    if (unlikely(!memview || (PyObject *) memview == Py_None))
-        return;
-    if (unlikely(__pyx_get_slice_count(memview) < 0))
-        __pyx_fatalerror("Acquisition count is %d (line %d)",
-                         __pyx_get_slice_count(memview), lineno);
-    first_time = __pyx_add_acquisition_count(memview) == 0;
-    if (unlikely(first_time)) {
-        if (have_gil) {
-            Py_INCREF((PyObject *) memview);
-        } else {
-            PyGILState_STATE _gilstate = PyGILState_Ensure();
-            Py_INCREF((PyObject *) memview);
-            PyGILState_Release(_gilstate);
-        }
-    }
-}
-static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice,
-                                             int have_gil, int lineno) {
-    int last_time;
-    struct __pyx_memoryview_obj *memview = memslice->memview;
-    if (unlikely(!memview || (PyObject *) memview == Py_None)) {
-        memslice->memview = NULL;
-        return;
-    }
-    if (unlikely(__pyx_get_slice_count(memview) <= 0))
-        __pyx_fatalerror("Acquisition count is %d (line %d)",
-                         __pyx_get_slice_count(memview), lineno);
-    last_time = __pyx_sub_acquisition_count(memview) == 1;
-    memslice->data = NULL;
-    if (unlikely(last_time)) {
-        if (have_gil) {
-            Py_CLEAR(memslice->memview);
-        } else {
-            PyGILState_STATE _gilstate = PyGILState_Ensure();
-            Py_CLEAR(memslice->memview);
-            PyGILState_Release(_gilstate);
-        }
-    } else {
-        memslice->memview = NULL;
-    }
-}
-
-/* RaiseArgTupleInvalid */
-static void __Pyx_RaiseArgtupleInvalid(
-    const char* func_name,
-    int exact,
-    Py_ssize_t num_min,
-    Py_ssize_t num_max,
-    Py_ssize_t num_found)
-{
-    Py_ssize_t num_expected;
-    const char *more_or_less;
-    if (num_found < num_min) {
-        num_expected = num_min;
-        more_or_less = "at least";
-    } else {
-        num_expected = num_max;
-        more_or_less = "at most";
-    }
-    if (exact) {
-        more_or_less = "exactly";
-    }
-    PyErr_Format(PyExc_TypeError,
-                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
-                 func_name, more_or_less, num_expected,
-                 (num_expected == 1) ? "" : "s", num_found);
-}
-
-/* RaiseDoubleKeywords */
-static void __Pyx_RaiseDoubleKeywordsError(
-    const char* func_name,
-    PyObject* kw_name)
-{
-    PyErr_Format(PyExc_TypeError,
-        #if PY_MAJOR_VERSION >= 3
-        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
-        #else
-        "%s() got multiple values for keyword argument '%s'", func_name,
-        PyString_AsString(kw_name));
-        #endif
-}
-
-/* ParseKeywords */
-static int __Pyx_ParseOptionalKeywords(
-    PyObject *kwds,
-    PyObject **argnames[],
-    PyObject *kwds2,
-    PyObject *values[],
-    Py_ssize_t num_pos_args,
-    const char* function_name)
-{
-    PyObject *key = 0, *value = 0;
-    Py_ssize_t pos = 0;
-    PyObject*** name;
-    PyObject*** first_kw_arg = argnames + num_pos_args;
-    while (PyDict_Next(kwds, &pos, &key, &value)) {
-        name = first_kw_arg;
-        while (*name && (**name != key)) name++;
-        if (*name) {
-            values[name-argnames] = value;
-            continue;
-        }
-        name = first_kw_arg;
-        #if PY_MAJOR_VERSION < 3
-        if (likely(PyString_Check(key))) {
-            while (*name) {
-                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
-                        && _PyString_Eq(**name, key)) {
-                    values[name-argnames] = value;
-                    break;
-                }
-                name++;
-            }
-            if (*name) continue;
-            else {
-                PyObject*** argname = argnames;
-                while (argname != first_kw_arg) {
-                    if ((**argname == key) || (
-                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
-                             && _PyString_Eq(**argname, key))) {
-                        goto arg_passed_twice;
-                    }
-                    argname++;
-                }
-            }
-        } else
-        #endif
-        if (likely(PyUnicode_Check(key))) {
-            while (*name) {
-                int cmp = (**name == key) ? 0 :
-                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
-                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
-                #endif
-                    PyUnicode_Compare(**name, key);
-                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
-                if (cmp == 0) {
-                    values[name-argnames] = value;
-                    break;
-                }
-                name++;
-            }
-            if (*name) continue;
-            else {
-                PyObject*** argname = argnames;
-                while (argname != first_kw_arg) {
-                    int cmp = (**argname == key) ? 0 :
-                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
-                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
-                    #endif
-                        PyUnicode_Compare(**argname, key);
-                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
-                    if (cmp == 0) goto arg_passed_twice;
-                    argname++;
-                }
-            }
-        } else
-            goto invalid_keyword_type;
-        if (kwds2) {
-            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
-        } else {
-            goto invalid_keyword;
-        }
-    }
-    return 0;
-arg_passed_twice:
-    __Pyx_RaiseDoubleKeywordsError(function_name, key);
-    goto bad;
-invalid_keyword_type:
-    PyErr_Format(PyExc_TypeError,
-        "%.200s() keywords must be strings", function_name);
-    goto bad;
-invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
-    #if PY_MAJOR_VERSION < 3
-        "%.200s() got an unexpected keyword argument '%.200s'",
-        function_name, PyString_AsString(key));
-    #else
-        "%s() got an unexpected keyword argument '%U'",
-        function_name, key);
-    #endif
-bad:
-    return -1;
-}
-
-/* None */
-static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) {
-    PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname);
-}
-
-/* ArgTypeTest */
-static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
-{
-    if (unlikely(!type)) {
-        PyErr_SetString(PyExc_SystemError, "Missing type object");
-        return 0;
-    }
-    else if (exact) {
-        #if PY_MAJOR_VERSION == 2
-        if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
-        #endif
-    }
-    else {
-        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
-    }
-    PyErr_Format(PyExc_TypeError,
-        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
-        name, type->tp_name, Py_TYPE(obj)->tp_name);
-    return 0;
-}
-
-/* PyObjectCall */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
-    PyObject *result;
-    ternaryfunc call = func->ob_type->tp_call;
-    if (unlikely(!call))
-        return PyObject_Call(func, arg, kw);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
-        return NULL;
-    result = (*call)(func, arg, kw);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
-    }
-    return result;
-}
-#endif
-
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-}
-#endif
-
-/* RaiseException */
-#if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
-    __Pyx_PyThreadState_declare
-    Py_XINCREF(type);
-    if (!value || value == Py_None)
-        value = NULL;
-    else
-        Py_INCREF(value);
-    if (!tb || tb == Py_None)
-        tb = NULL;
-    else {
-        Py_INCREF(tb);
-        if (!PyTraceBack_Check(tb)) {
-            PyErr_SetString(PyExc_TypeError,
-                "raise: arg 3 must be a traceback or None");
-            goto raise_error;
-        }
-    }
-    if (PyType_Check(type)) {
-#if CYTHON_COMPILING_IN_PYPY
-        if (!value) {
-            Py_INCREF(Py_None);
-            value = Py_None;
-        }
-#endif
-        PyErr_NormalizeException(&type, &value, &tb);
-    } else {
-        if (value) {
-            PyErr_SetString(PyExc_TypeError,
-                "instance exception may not have a separate value");
-            goto raise_error;
-        }
-        value = type;
-        type = (PyObject*) Py_TYPE(type);
-        Py_INCREF(type);
-        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
-            PyErr_SetString(PyExc_TypeError,
-                "raise: exception class must be a subclass of BaseException");
-            goto raise_error;
-        }
-    }
-    __Pyx_PyThreadState_assign
-    __Pyx_ErrRestore(type, value, tb);
-    return;
-raise_error:
-    Py_XDECREF(value);
-    Py_XDECREF(type);
-    Py_XDECREF(tb);
-    return;
-}
-#else
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
-    PyObject* owned_instance = NULL;
-    if (tb == Py_None) {
-        tb = 0;
-    } else if (tb && !PyTraceBack_Check(tb)) {
-        PyErr_SetString(PyExc_TypeError,
-            "raise: arg 3 must be a traceback or None");
-        goto bad;
-    }
-    if (value == Py_None)
-        value = 0;
-    if (PyExceptionInstance_Check(type)) {
-        if (value) {
-            PyErr_SetString(PyExc_TypeError,
-                "instance exception may not have a separate value");
-            goto bad;
-        }
-        value = type;
-        type = (PyObject*) Py_TYPE(value);
-    } else if (PyExceptionClass_Check(type)) {
-        PyObject *instance_class = NULL;
-        if (value && PyExceptionInstance_Check(value)) {
-            instance_class = (PyObject*) Py_TYPE(value);
-            if (instance_class != type) {
-                int is_subclass = PyObject_IsSubclass(instance_class, type);
-                if (!is_subclass) {
-                    instance_class = NULL;
-                } else if (unlikely(is_subclass == -1)) {
-                    goto bad;
-                } else {
-                    type = instance_class;
-                }
-            }
-        }
-        if (!instance_class) {
-            PyObject *args;
-            if (!value)
-                args = PyTuple_New(0);
-            else if (PyTuple_Check(value)) {
-                Py_INCREF(value);
-                args = value;
-            } else
-                args = PyTuple_Pack(1, value);
-            if (!args)
-                goto bad;
-            owned_instance = PyObject_Call(type, args, NULL);
-            Py_DECREF(args);
-            if (!owned_instance)
-                goto bad;
-            value = owned_instance;
-            if (!PyExceptionInstance_Check(value)) {
-                PyErr_Format(PyExc_TypeError,
-                             "calling %R should have returned an instance of "
-                             "BaseException, not %R",
-                             type, Py_TYPE(value));
-                goto bad;
-            }
-        }
-    } else {
-        PyErr_SetString(PyExc_TypeError,
-            "raise: exception class must be a subclass of BaseException");
-        goto bad;
-    }
-    if (cause) {
-        PyObject *fixed_cause;
-        if (cause == Py_None) {
-            fixed_cause = NULL;
-        } else if (PyExceptionClass_Check(cause)) {
-            fixed_cause = PyObject_CallObject(cause, NULL);
-            if (fixed_cause == NULL)
-                goto bad;
-        } else if (PyExceptionInstance_Check(cause)) {
-            fixed_cause = cause;
-            Py_INCREF(fixed_cause);
-        } else {
-            PyErr_SetString(PyExc_TypeError,
-                            "exception causes must derive from "
-                            "BaseException");
-            goto bad;
-        }
-        PyException_SetCause(value, fixed_cause);
-    }
-    PyErr_SetObject(type, value);
-    if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#else
-        PyThreadState *tstate = __Pyx_PyThreadState_Current;
-        PyObject* tmp_tb = tstate->curexc_traceback;
-        if (tb != tmp_tb) {
-            Py_INCREF(tb);
-            tstate->curexc_traceback = tb;
-            Py_XDECREF(tmp_tb);
-        }
-#endif
-    }
-bad:
-    Py_XDECREF(owned_instance);
-    return;
-}
-#endif
-
-/* PyCFunctionFastCall */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
-    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
-    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
-    PyObject *self = PyCFunction_GET_SELF(func);
-    int flags = PyCFunction_GET_FLAGS(func);
-    assert(PyCFunction_Check(func));
-    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
-    assert(nargs >= 0);
-    assert(nargs == 0 || args != NULL);
-    /* _PyCFunction_FastCallDict() must not be called with an exception set,
-       because it may clear it (directly or indirectly) and so the
-       caller loses its exception */
-    assert(!PyErr_Occurred());
-    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
-        return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
-    } else {
-        return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
-    }
-}
-#endif
-
-/* PyFunctionFastCall */
-#if CYTHON_FAST_PYCALL
-static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
-                                               PyObject *globals) {
-    PyFrameObject *f;
-    PyThreadState *tstate = __Pyx_PyThreadState_Current;
-    PyObject **fastlocals;
-    Py_ssize_t i;
-    PyObject *result;
-    assert(globals != NULL);
-    /* XXX Perhaps we should create a specialized
-       PyFrame_New() that doesn't take locals, but does
-       take builtins without sanity checking them.
-       */
-    assert(tstate != NULL);
-    f = PyFrame_New(tstate, co, globals, NULL);
-    if (f == NULL) {
-        return NULL;
-    }
-    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
-    for (i = 0; i < na; i++) {
-        Py_INCREF(*args);
-        fastlocals[i] = *args++;
-    }
-    result = PyEval_EvalFrameEx(f,0);
-    ++tstate->recursion_depth;
-    Py_DECREF(f);
-    --tstate->recursion_depth;
-    return result;
-}
-#if 1 || PY_VERSION_HEX < 0x030600B1
-static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
-    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
-    PyObject *globals = PyFunction_GET_GLOBALS(func);
-    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
-    PyObject *closure;
-#if PY_MAJOR_VERSION >= 3
-    PyObject *kwdefs;
-#endif
-    PyObject *kwtuple, **k;
-    PyObject **d;
-    Py_ssize_t nd;
-    Py_ssize_t nk;
-    PyObject *result;
-    assert(kwargs == NULL || PyDict_Check(kwargs));
-    nk = kwargs ? PyDict_Size(kwargs) : 0;
-    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
-        return NULL;
-    }
-    if (
-#if PY_MAJOR_VERSION >= 3
-            co->co_kwonlyargcount == 0 &&
-#endif
-            likely(kwargs == NULL || nk == 0) &&
-            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
-        if (argdefs == NULL && co->co_argcount == nargs) {
-            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
-            goto done;
-        }
-        else if (nargs == 0 && argdefs != NULL
-                 && co->co_argcount == Py_SIZE(argdefs)) {
-            /* function called with no arguments, but all parameters have
-               a default value: use default values as arguments .*/
-            args = &PyTuple_GET_ITEM(argdefs, 0);
-            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
-            goto done;
-        }
-    }
-    if (kwargs != NULL) {
-        Py_ssize_t pos, i;
-        kwtuple = PyTuple_New(2 * nk);
-        if (kwtuple == NULL) {
-            result = NULL;
-            goto done;
-        }
-        k = &PyTuple_GET_ITEM(kwtuple, 0);
-        pos = i = 0;
-        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
-            Py_INCREF(k[i]);
-            Py_INCREF(k[i+1]);
-            i += 2;
-        }
-        nk = i / 2;
-    }
-    else {
-        kwtuple = NULL;
-        k = NULL;
-    }
-    closure = PyFunction_GET_CLOSURE(func);
-#if PY_MAJOR_VERSION >= 3
-    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
-#endif
-    if (argdefs != NULL) {
-        d = &PyTuple_GET_ITEM(argdefs, 0);
-        nd = Py_SIZE(argdefs);
-    }
-    else {
-        d = NULL;
-        nd = 0;
-    }
-#if PY_MAJOR_VERSION >= 3
-    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
-                               args, (int)nargs,
-                               k, (int)nk,
-                               d, (int)nd, kwdefs, closure);
-#else
-    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
-                               args, (int)nargs,
-                               k, (int)nk,
-                               d, (int)nd, closure);
-#endif
-    Py_XDECREF(kwtuple);
-done:
-    Py_LeaveRecursiveCall();
-    return result;
-}
-#endif
-#endif
-
-/* PyObjectCall2Args */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
-    PyObject *args, *result = NULL;
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyFunction_FastCall(function, args, 2);
-    }
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyCFunction_FastCall(function, args, 2);
-    }
-    #endif
-    args = PyTuple_New(2);
-    if (unlikely(!args)) goto done;
-    Py_INCREF(arg1);
-    PyTuple_SET_ITEM(args, 0, arg1);
-    Py_INCREF(arg2);
-    PyTuple_SET_ITEM(args, 1, arg2);
-    Py_INCREF(function);
-    result = __Pyx_PyObject_Call(function, args, NULL);
-    Py_DECREF(args);
-    Py_DECREF(function);
-done:
-    return result;
-}
-
-/* PyObjectCallMethO */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
-    PyObject *self, *result;
-    PyCFunction cfunc;
-    cfunc = PyCFunction_GET_FUNCTION(func);
-    self = PyCFunction_GET_SELF(func);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
-        return NULL;
-    result = cfunc(self, arg);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
-    }
-    return result;
-}
-#endif
-
-/* PyObjectCallOneArg */
-#if CYTHON_COMPILING_IN_CPYTHON
-static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_New(1);
-    if (unlikely(!args)) return NULL;
-    Py_INCREF(arg);
-    PyTuple_SET_ITEM(args, 0, arg);
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, &arg, 1);
-    }
-#endif
-    if (likely(PyCFunction_Check(func))) {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
-            return __Pyx_PyObject_CallMethO(func, arg);
-#if CYTHON_FAST_PYCCALL
-        } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) {
-            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
-#endif
-        }
-    }
-    return __Pyx__PyObject_CallOneArg(func, arg);
-}
-#else
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_Pack(1, arg);
-    if (unlikely(!args)) return NULL;
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
-}
-#endif
-
-/* BytesEquals */
-static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
-#if CYTHON_COMPILING_IN_PYPY
-    return PyObject_RichCompareBool(s1, s2, equals);
-#else
-    if (s1 == s2) {
-        return (equals == Py_EQ);
-    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
-        const char *ps1, *ps2;
-        Py_ssize_t length = PyBytes_GET_SIZE(s1);
-        if (length != PyBytes_GET_SIZE(s2))
-            return (equals == Py_NE);
-        ps1 = PyBytes_AS_STRING(s1);
-        ps2 = PyBytes_AS_STRING(s2);
-        if (ps1[0] != ps2[0]) {
-            return (equals == Py_NE);
-        } else if (length == 1) {
-            return (equals == Py_EQ);
-        } else {
-            int result;
-#if CYTHON_USE_UNICODE_INTERNALS
-            Py_hash_t hash1, hash2;
-            hash1 = ((PyBytesObject*)s1)->ob_shash;
-            hash2 = ((PyBytesObject*)s2)->ob_shash;
-            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
-                return (equals == Py_NE);
-            }
-#endif
-            result = memcmp(ps1, ps2, (size_t)length);
-            return (equals == Py_EQ) ? (result == 0) : (result != 0);
-        }
-    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
-        return (equals == Py_NE);
-    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
-        return (equals == Py_NE);
-    } else {
-        int result;
-        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
-        if (!py_result)
-            return -1;
-        result = __Pyx_PyObject_IsTrue(py_result);
-        Py_DECREF(py_result);
-        return result;
-    }
-#endif
-}
-
-/* UnicodeEquals */
-static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
-#if CYTHON_COMPILING_IN_PYPY
-    return PyObject_RichCompareBool(s1, s2, equals);
-#else
-#if PY_MAJOR_VERSION < 3
-    PyObject* owned_ref = NULL;
-#endif
-    int s1_is_unicode, s2_is_unicode;
-    if (s1 == s2) {
-        goto return_eq;
-    }
-    s1_is_unicode = PyUnicode_CheckExact(s1);
-    s2_is_unicode = PyUnicode_CheckExact(s2);
-#if PY_MAJOR_VERSION < 3
-    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
-        owned_ref = PyUnicode_FromObject(s2);
-        if (unlikely(!owned_ref))
-            return -1;
-        s2 = owned_ref;
-        s2_is_unicode = 1;
-    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
-        owned_ref = PyUnicode_FromObject(s1);
-        if (unlikely(!owned_ref))
-            return -1;
-        s1 = owned_ref;
-        s1_is_unicode = 1;
-    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
-        return __Pyx_PyBytes_Equals(s1, s2, equals);
-    }
-#endif
-    if (s1_is_unicode & s2_is_unicode) {
-        Py_ssize_t length;
-        int kind;
-        void *data1, *data2;
-        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
-            return -1;
-        length = __Pyx_PyUnicode_GET_LENGTH(s1);
-        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
-            goto return_ne;
-        }
-#if CYTHON_USE_UNICODE_INTERNALS
-        {
-            Py_hash_t hash1, hash2;
-        #if CYTHON_PEP393_ENABLED
-            hash1 = ((PyASCIIObject*)s1)->hash;
-            hash2 = ((PyASCIIObject*)s2)->hash;
-        #else
-            hash1 = ((PyUnicodeObject*)s1)->hash;
-            hash2 = ((PyUnicodeObject*)s2)->hash;
-        #endif
-            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
-                goto return_ne;
-            }
-        }
-#endif
-        kind = __Pyx_PyUnicode_KIND(s1);
-        if (kind != __Pyx_PyUnicode_KIND(s2)) {
-            goto return_ne;
-        }
-        data1 = __Pyx_PyUnicode_DATA(s1);
-        data2 = __Pyx_PyUnicode_DATA(s2);
-        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
-            goto return_ne;
-        } else if (length == 1) {
-            goto return_eq;
-        } else {
-            int result = memcmp(data1, data2, (size_t)(length * kind));
-            #if PY_MAJOR_VERSION < 3
-            Py_XDECREF(owned_ref);
-            #endif
-            return (equals == Py_EQ) ? (result == 0) : (result != 0);
-        }
-    } else if ((s1 == Py_None) & s2_is_unicode) {
-        goto return_ne;
-    } else if ((s2 == Py_None) & s1_is_unicode) {
-        goto return_ne;
-    } else {
-        int result;
-        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
-        #if PY_MAJOR_VERSION < 3
-        Py_XDECREF(owned_ref);
-        #endif
-        if (!py_result)
-            return -1;
-        result = __Pyx_PyObject_IsTrue(py_result);
-        Py_DECREF(py_result);
-        return result;
-    }
-return_eq:
-    #if PY_MAJOR_VERSION < 3
-    Py_XDECREF(owned_ref);
-    #endif
-    return (equals == Py_EQ);
-return_ne:
-    #if PY_MAJOR_VERSION < 3
-    Py_XDECREF(owned_ref);
-    #endif
-    return (equals == Py_NE);
-#endif
-}
-
-/* None */
-static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) {
-    Py_ssize_t q = a / b;
-    Py_ssize_t r = a - q*b;
-    q -= ((r != 0) & ((r ^ b) < 0));
-    return q;
-}
-
-/* GetAttr */
-static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) {
-#if CYTHON_USE_TYPE_SLOTS
-#if PY_MAJOR_VERSION >= 3
-    if (likely(PyUnicode_Check(n)))
-#else
-    if (likely(PyString_Check(n)))
-#endif
-        return __Pyx_PyObject_GetAttrStr(o, n);
-#endif
-    return PyObject_GetAttr(o, n);
-}
-
-/* GetItemInt */
-static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
-    PyObject *r;
-    if (!j) return NULL;
-    r = PyObject_GetItem(o, j);
-    Py_DECREF(j);
-    return r;
-}
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
-                                                              CYTHON_NCP_UNUSED int wraparound,
-                                                              CYTHON_NCP_UNUSED int boundscheck) {
-#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    Py_ssize_t wrapped_i = i;
-    if (wraparound & unlikely(i < 0)) {
-        wrapped_i += PyList_GET_SIZE(o);
-    }
-    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) {
-        PyObject *r = PyList_GET_ITEM(o, wrapped_i);
-        Py_INCREF(r);
-        return r;
-    }
-    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
-#else
-    return PySequence_GetItem(o, i);
-#endif
-}
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
-                                                              CYTHON_NCP_UNUSED int wraparound,
-                                                              CYTHON_NCP_UNUSED int boundscheck) {
-#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    Py_ssize_t wrapped_i = i;
-    if (wraparound & unlikely(i < 0)) {
-        wrapped_i += PyTuple_GET_SIZE(o);
-    }
-    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) {
-        PyObject *r = PyTuple_GET_ITEM(o, wrapped_i);
-        Py_INCREF(r);
-        return r;
-    }
-    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
-#else
-    return PySequence_GetItem(o, i);
-#endif
-}
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
-                                                     CYTHON_NCP_UNUSED int wraparound,
-                                                     CYTHON_NCP_UNUSED int boundscheck) {
-#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
-    if (is_list || PyList_CheckExact(o)) {
-        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
-        if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) {
-            PyObject *r = PyList_GET_ITEM(o, n);
-            Py_INCREF(r);
-            return r;
-        }
-    }
-    else if (PyTuple_CheckExact(o)) {
-        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
-        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) {
-            PyObject *r = PyTuple_GET_ITEM(o, n);
-            Py_INCREF(r);
-            return r;
-        }
-    } else {
-        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
-        if (likely(m && m->sq_item)) {
-            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
-                Py_ssize_t l = m->sq_length(o);
-                if (likely(l >= 0)) {
-                    i += l;
-                } else {
-                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
-                        return NULL;
-                    PyErr_Clear();
-                }
-            }
-            return m->sq_item(o, i);
-        }
-    }
-#else
-    if (is_list || PySequence_Check(o)) {
-        return PySequence_GetItem(o, i);
-    }
-#endif
-    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
-}
-
-/* ObjectGetItem */
-#if CYTHON_USE_TYPE_SLOTS
-static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) {
-    PyObject *runerr;
-    Py_ssize_t key_value;
-    PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence;
-    if (unlikely(!(m && m->sq_item))) {
-        PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name);
-        return NULL;
-    }
-    key_value = __Pyx_PyIndex_AsSsize_t(index);
-    if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) {
-        return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1);
-    }
-    if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) {
-        PyErr_Clear();
-        PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name);
-    }
-    return NULL;
-}
-static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) {
-    PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping;
-    if (likely(m && m->mp_subscript)) {
-        return m->mp_subscript(obj, key);
-    }
-    return __Pyx_PyObject_GetIndex(obj, key);
-}
-#endif
-
-/* decode_c_string */
-static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
-         const char* cstring, Py_ssize_t start, Py_ssize_t stop,
-         const char* encoding, const char* errors,
-         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
-    Py_ssize_t length;
-    if (unlikely((start < 0) | (stop < 0))) {
-        size_t slen = strlen(cstring);
-        if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) {
-            PyErr_SetString(PyExc_OverflowError,
-                            "c-string too long to convert to Python");
-            return NULL;
-        }
-        length = (Py_ssize_t) slen;
-        if (start < 0) {
-            start += length;
-            if (start < 0)
-                start = 0;
-        }
-        if (stop < 0)
-            stop += length;
-    }
-    if (unlikely(stop <= start))
-        return __Pyx_NewRef(__pyx_empty_unicode);
-    length = stop - start;
-    cstring += start;
-    if (decode_func) {
-        return decode_func(cstring, length, errors);
-    } else {
-        return PyUnicode_Decode(cstring, length, encoding, errors);
-    }
-}
-
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
-    }
-#endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
-    }
-    return 0;
-}
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
-}
-#endif
-
-/* GetAttr3 */
-static PyObject *__Pyx_GetAttr3Default(PyObject *d) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        return NULL;
-    __Pyx_PyErr_Clear();
-    Py_INCREF(d);
-    return d;
-}
-static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) {
-    PyObject *r = __Pyx_GetAttr(o, n);
-    return (likely(r)) ? r : __Pyx_GetAttr3Default(d);
-}
-
-/* PyDictVersioning */
-#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
-    PyObject *dict = Py_TYPE(obj)->tp_dict;
-    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
-}
-static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
-    PyObject **dictptr = NULL;
-    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
-    if (offset) {
-#if CYTHON_COMPILING_IN_CPYTHON
-        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
-#else
-        dictptr = _PyObject_GetDictPtr(obj);
-#endif
-    }
-    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
-}
-static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
-    PyObject *dict = Py_TYPE(obj)->tp_dict;
-    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
-        return 0;
-    return obj_dict_version == __Pyx_get_object_dict_version(obj);
-}
-#endif
-
-/* GetModuleGlobalName */
-#if CYTHON_USE_DICT_VERSIONS
-static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
-#else
-static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
-#endif
-{
-    PyObject *result;
-#if !CYTHON_AVOID_BORROWED_REFS
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
-    result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
-    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
-    if (likely(result)) {
-        return __Pyx_NewRef(result);
-    } else if (unlikely(PyErr_Occurred())) {
-        return NULL;
-    }
-#else
-    result = PyDict_GetItem(__pyx_d, name);
-    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
-    if (likely(result)) {
-        return __Pyx_NewRef(result);
-    }
-#endif
-#else
-    result = PyObject_GetItem(__pyx_d, name);
-    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
-    if (likely(result)) {
-        return __Pyx_NewRef(result);
-    }
-    PyErr_Clear();
-#endif
-    return __Pyx_GetBuiltinName(name);
-}
-
-/* RaiseTooManyValuesToUnpack */
-static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
-    PyErr_Format(PyExc_ValueError,
-                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
-}
-
-/* RaiseNeedMoreValuesToUnpack */
-static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
-    PyErr_Format(PyExc_ValueError,
-                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
-                 index, (index == 1) ? "" : "s");
-}
-
-/* RaiseNoneIterError */
-static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
-    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
-}
-
-/* ExtTypeTest */
-static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
-    if (unlikely(!type)) {
-        PyErr_SetString(PyExc_SystemError, "Missing type object");
-        return 0;
-    }
-    if (likely(__Pyx_TypeCheck(obj, type)))
-        return 1;
-    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
-                 Py_TYPE(obj)->tp_name, type->tp_name);
-    return 0;
-}
-
-/* GetTopmostException */
-#if CYTHON_USE_EXC_INFO_STACK
-static _PyErr_StackItem *
-__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
-{
-    _PyErr_StackItem *exc_info = tstate->exc_info;
-    while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
-           exc_info->previous_item != NULL)
-    {
-        exc_info = exc_info->previous_item;
-    }
-    return exc_info;
-}
-#endif
-
-/* SaveResetException */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    #if CYTHON_USE_EXC_INFO_STACK
-    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
-    *type = exc_info->exc_type;
-    *value = exc_info->exc_value;
-    *tb = exc_info->exc_traceback;
-    #else
-    *type = tstate->exc_type;
-    *value = tstate->exc_value;
-    *tb = tstate->exc_traceback;
-    #endif
-    Py_XINCREF(*type);
-    Py_XINCREF(*value);
-    Py_XINCREF(*tb);
-}
-static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    #if CYTHON_USE_EXC_INFO_STACK
-    _PyErr_StackItem *exc_info = tstate->exc_info;
-    tmp_type = exc_info->exc_type;
-    tmp_value = exc_info->exc_value;
-    tmp_tb = exc_info->exc_traceback;
-    exc_info->exc_type = type;
-    exc_info->exc_value = value;
-    exc_info->exc_traceback = tb;
-    #else
-    tmp_type = tstate->exc_type;
-    tmp_value = tstate->exc_value;
-    tmp_tb = tstate->exc_traceback;
-    tstate->exc_type = type;
-    tstate->exc_value = value;
-    tstate->exc_traceback = tb;
-    #endif
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-#endif
-
-/* GetException */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
-#else
-static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
-#endif
-{
-    PyObject *local_type, *local_value, *local_tb;
-#if CYTHON_FAST_THREAD_STATE
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    local_type = tstate->curexc_type;
-    local_value = tstate->curexc_value;
-    local_tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-#else
-    PyErr_Fetch(&local_type, &local_value, &local_tb);
-#endif
-    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
-#if CYTHON_FAST_THREAD_STATE
-    if (unlikely(tstate->curexc_type))
-#else
-    if (unlikely(PyErr_Occurred()))
-#endif
-        goto bad;
-    #if PY_MAJOR_VERSION >= 3
-    if (local_tb) {
-        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
-            goto bad;
-    }
-    #endif
-    Py_XINCREF(local_tb);
-    Py_XINCREF(local_type);
-    Py_XINCREF(local_value);
-    *type = local_type;
-    *value = local_value;
-    *tb = local_tb;
-#if CYTHON_FAST_THREAD_STATE
-    #if CYTHON_USE_EXC_INFO_STACK
-    {
-        _PyErr_StackItem *exc_info = tstate->exc_info;
-        tmp_type = exc_info->exc_type;
-        tmp_value = exc_info->exc_value;
-        tmp_tb = exc_info->exc_traceback;
-        exc_info->exc_type = local_type;
-        exc_info->exc_value = local_value;
-        exc_info->exc_traceback = local_tb;
-    }
-    #else
-    tmp_type = tstate->exc_type;
-    tmp_value = tstate->exc_value;
-    tmp_tb = tstate->exc_traceback;
-    tstate->exc_type = local_type;
-    tstate->exc_value = local_value;
-    tstate->exc_traceback = local_tb;
-    #endif
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-#else
-    PyErr_SetExcInfo(local_type, local_value, local_tb);
-#endif
-    return 0;
-bad:
-    *type = 0;
-    *value = 0;
-    *tb = 0;
-    Py_XDECREF(local_type);
-    Py_XDECREF(local_value);
-    Py_XDECREF(local_tb);
-    return -1;
-}
-
-/* SwapException */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    #if CYTHON_USE_EXC_INFO_STACK
-    _PyErr_StackItem *exc_info = tstate->exc_info;
-    tmp_type = exc_info->exc_type;
-    tmp_value = exc_info->exc_value;
-    tmp_tb = exc_info->exc_traceback;
-    exc_info->exc_type = *type;
-    exc_info->exc_value = *value;
-    exc_info->exc_traceback = *tb;
-    #else
-    tmp_type = tstate->exc_type;
-    tmp_value = tstate->exc_value;
-    tmp_tb = tstate->exc_traceback;
-    tstate->exc_type = *type;
-    tstate->exc_value = *value;
-    tstate->exc_traceback = *tb;
-    #endif
-    *type = tmp_type;
-    *value = tmp_value;
-    *tb = tmp_tb;
-}
-#else
-static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
-    PyErr_SetExcInfo(*type, *value, *tb);
-    *type = tmp_type;
-    *value = tmp_value;
-    *tb = tmp_tb;
-}
-#endif
-
-/* Import */
-static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
-    PyObject *empty_list = 0;
-    PyObject *module = 0;
-    PyObject *global_dict = 0;
-    PyObject *empty_dict = 0;
-    PyObject *list;
-    #if PY_MAJOR_VERSION < 3
-    PyObject *py_import;
-    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
-    if (!py_import)
-        goto bad;
-    #endif
-    if (from_list)
-        list = from_list;
-    else {
-        empty_list = PyList_New(0);
-        if (!empty_list)
-            goto bad;
-        list = empty_list;
-    }
-    global_dict = PyModule_GetDict(__pyx_m);
-    if (!global_dict)
-        goto bad;
-    empty_dict = PyDict_New();
-    if (!empty_dict)
-        goto bad;
-    {
-        #if PY_MAJOR_VERSION >= 3
-        if (level == -1) {
-            if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) {
-                module = PyImport_ImportModuleLevelObject(
-                    name, global_dict, empty_dict, list, 1);
-                if (!module) {
-                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
-                        goto bad;
-                    PyErr_Clear();
-                }
-            }
-            level = 0;
-        }
-        #endif
-        if (!module) {
-            #if PY_MAJOR_VERSION < 3
-            PyObject *py_level = PyInt_FromLong(level);
-            if (!py_level)
-                goto bad;
-            module = PyObject_CallFunctionObjArgs(py_import,
-                name, global_dict, empty_dict, list, py_level, (PyObject *)NULL);
-            Py_DECREF(py_level);
-            #else
-            module = PyImport_ImportModuleLevelObject(
-                name, global_dict, empty_dict, list, level);
-            #endif
-        }
-    }
-bad:
-    #if PY_MAJOR_VERSION < 3
-    Py_XDECREF(py_import);
-    #endif
-    Py_XDECREF(empty_list);
-    Py_XDECREF(empty_dict);
-    return module;
-}
-
-/* FastTypeChecks */
-#if CYTHON_COMPILING_IN_CPYTHON
-static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
-    while (a) {
-        a = a->tp_base;
-        if (a == b)
-            return 1;
-    }
-    return b == &PyBaseObject_Type;
-}
-static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
-    PyObject *mro;
-    if (a == b) return 1;
-    mro = a->tp_mro;
-    if (likely(mro)) {
-        Py_ssize_t i, n;
-        n = PyTuple_GET_SIZE(mro);
-        for (i = 0; i < n; i++) {
-            if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
-                return 1;
-        }
-        return 0;
-    }
-    return __Pyx_InBases(a, b);
-}
-#if PY_MAJOR_VERSION == 2
-static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
-    PyObject *exception, *value, *tb;
-    int res;
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    __Pyx_ErrFetch(&exception, &value, &tb);
-    res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0;
-    if (unlikely(res == -1)) {
-        PyErr_WriteUnraisable(err);
-        res = 0;
-    }
-    if (!res) {
-        res = PyObject_IsSubclass(err, exc_type2);
-        if (unlikely(res == -1)) {
-            PyErr_WriteUnraisable(err);
-            res = 0;
-        }
-    }
-    __Pyx_ErrRestore(exception, value, tb);
-    return res;
-}
-#else
-static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
-    }
-    return res;
-}
-#endif
-static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    assert(PyExceptionClass_Check(exc_type));
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
-    }
-#endif
-    for (i=0; i<n; i++) {
-        PyObject *t = PyTuple_GET_ITEM(tuple, i);
-        #if PY_MAJOR_VERSION < 3
-        if (likely(exc_type == t)) return 1;
-        #endif
-        if (likely(PyExceptionClass_Check(t))) {
-            if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
-        } else {
-        }
-    }
-    return 0;
-}
-static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
-    if (likely(err == exc_type)) return 1;
-    if (likely(PyExceptionClass_Check(err))) {
-        if (likely(PyExceptionClass_Check(exc_type))) {
-            return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
-        } else if (likely(PyTuple_Check(exc_type))) {
-            return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
-        } else {
-        }
-    }
-    return PyErr_GivenExceptionMatches(err, exc_type);
-}
-static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
-    assert(PyExceptionClass_Check(exc_type1));
-    assert(PyExceptionClass_Check(exc_type2));
-    if (likely(err == exc_type1 || err == exc_type2)) return 1;
-    if (likely(PyExceptionClass_Check(err))) {
-        return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
-    }
-    return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
-}
-#endif
-
-/* PyIntBinop */
-#if !CYTHON_COMPILING_IN_PYPY
-static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) {
-    (void)inplace;
-    (void)zerodivision_check;
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_CheckExact(op1))) {
-        const long b = intval;
-        long x;
-        long a = PyInt_AS_LONG(op1);
-            x = (long)((unsigned long)a + b);
-            if (likely((x^a) >= 0 || (x^b) >= 0))
-                return PyInt_FromLong(x);
-            return PyLong_Type.tp_as_number->nb_add(op1, op2);
-    }
-    #endif
-    #if CYTHON_USE_PYLONG_INTERNALS
-    if (likely(PyLong_CheckExact(op1))) {
-        const long b = intval;
-        long a, x;
-#ifdef HAVE_LONG_LONG
-        const PY_LONG_LONG llb = intval;
-        PY_LONG_LONG lla, llx;
-#endif
-        const digit* digits = ((PyLongObject*)op1)->ob_digit;
-        const Py_ssize_t size = Py_SIZE(op1);
-        if (likely(__Pyx_sst_abs(size) <= 1)) {
-            a = likely(size) ? digits[0] : 0;
-            if (size == -1) a = -a;
-        } else {
-            switch (size) {
-                case -2:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
-                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
-#endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                case 2:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
-                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
-#endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                case -3:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
-                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
-#endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                case 3:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
-                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
-#endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                case -4:
-                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
-                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
-                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
-#endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                case 4:
-                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
-                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
-                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
-#endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
-            }
-        }
-                x = a + b;
-            return PyLong_FromLong(x);
-#ifdef HAVE_LONG_LONG
-        long_long:
-                llx = lla + llb;
-            return PyLong_FromLongLong(llx);
-#endif
-        
-        
-    }
-    #endif
-    if (PyFloat_CheckExact(op1)) {
-        const long b = intval;
-        double a = PyFloat_AS_DOUBLE(op1);
-            double result;
-            PyFPE_START_PROTECT("add", return NULL)
-            result = ((double)a) + (double)b;
-            PyFPE_END_PROTECT(result)
-            return PyFloat_FromDouble(result);
-    }
-    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
-}
-#endif
-
-/* None */
-static CYTHON_INLINE long __Pyx_div_long(long a, long b) {
-    long q = a / b;
-    long r = a - q*b;
-    q -= ((r != 0) & ((r ^ b) < 0));
-    return q;
-}
-
-/* ImportFrom */
-static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
-    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
-    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
-        PyErr_Format(PyExc_ImportError,
-        #if PY_MAJOR_VERSION < 3
-            "cannot import name %.230s", PyString_AS_STRING(name));
-        #else
-            "cannot import name %S", name);
-        #endif
-    }
-    return value;
-}
-
-/* HasAttr */
-static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) {
-    PyObject *r;
-    if (unlikely(!__Pyx_PyBaseString_Check(n))) {
-        PyErr_SetString(PyExc_TypeError,
-                        "hasattr(): attribute name must be string");
-        return -1;
-    }
-    r = __Pyx_GetAttr(o, n);
-    if (unlikely(!r)) {
-        PyErr_Clear();
-        return 0;
-    } else {
-        Py_DECREF(r);
-        return 1;
-    }
-}
-
-/* PyObject_GenericGetAttrNoDict */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
-    PyErr_Format(PyExc_AttributeError,
-#if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
-#else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
-#endif
-    return NULL;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
-    PyObject *descr;
-    PyTypeObject *tp = Py_TYPE(obj);
-    if (unlikely(!PyString_Check(attr_name))) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    assert(!tp->tp_dictoffset);
-    descr = _PyType_Lookup(tp, attr_name);
-    if (unlikely(!descr)) {
-        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
-    }
-    Py_INCREF(descr);
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
-    #endif
-    {
-        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
-        if (unlikely(f)) {
-            PyObject *res = f(descr, obj, (PyObject *)tp);
-            Py_DECREF(descr);
-            return res;
-        }
-    }
-    return descr;
-}
-#endif
-
-/* PyObject_GenericGetAttr */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
-    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
-}
-#endif
-
-/* SetVTable */
-static int __Pyx_SetVtable(PyObject *dict, void *vtable) {
-#if PY_VERSION_HEX >= 0x02070000
-    PyObject *ob = PyCapsule_New(vtable, 0, 0);
-#else
-    PyObject *ob = PyCObject_FromVoidPtr(vtable, 0);
-#endif
-    if (!ob)
-        goto bad;
-    if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0)
-        goto bad;
-    Py_DECREF(ob);
-    return 0;
-bad:
-    Py_XDECREF(ob);
-    return -1;
-}
-
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
-    PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
-    }
-#endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
-    }
-    return result;
-}
-
-/* SetupReduce */
-static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
-  int ret;
-  PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2);
-  if (likely(name_attr)) {
-      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
-  } else {
-      ret = -1;
-  }
-  if (unlikely(ret < 0)) {
-      PyErr_Clear();
-      ret = 0;
-  }
-  Py_XDECREF(name_attr);
-  return ret;
-}
-static int __Pyx_setup_reduce(PyObject* type_obj) {
-    int ret = 0;
-    PyObject *object_reduce = NULL;
-    PyObject *object_reduce_ex = NULL;
-    PyObject *reduce = NULL;
-    PyObject *reduce_ex = NULL;
-    PyObject *reduce_cython = NULL;
-    PyObject *setstate = NULL;
-    PyObject *setstate_cython = NULL;
-#if CYTHON_USE_PYTYPE_LOOKUP
-    if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
-#else
-    if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
-#endif
-#if CYTHON_USE_PYTYPE_LOOKUP
-    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
-#else
-    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
-#endif
-    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
-    if (reduce_ex == object_reduce_ex) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
-#else
-        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
-#endif
-        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
-        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
-            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
-            if (likely(reduce_cython)) {
-                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-            } else if (reduce == object_reduce || PyErr_Occurred()) {
-                goto __PYX_BAD;
-            }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
-            if (!setstate) PyErr_Clear();
-            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
-                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
-                if (likely(setstate_cython)) {
-                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                } else if (!setstate || PyErr_Occurred()) {
-                    goto __PYX_BAD;
-                }
-            }
-            PyType_Modified((PyTypeObject*)type_obj);
-        }
-    }
-    goto __PYX_GOOD;
-__PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
-    ret = -1;
-__PYX_GOOD:
-#if !CYTHON_USE_PYTYPE_LOOKUP
-    Py_XDECREF(object_reduce);
-    Py_XDECREF(object_reduce_ex);
-#endif
-    Py_XDECREF(reduce);
-    Py_XDECREF(reduce_ex);
-    Py_XDECREF(reduce_cython);
-    Py_XDECREF(setstate);
-    Py_XDECREF(setstate_cython);
-    return ret;
-}
-
-/* CLineInTraceback */
-#ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
-    PyObject *use_cline;
-    PyObject *ptype, *pvalue, *ptraceback;
-#if CYTHON_COMPILING_IN_CPYTHON
-    PyObject **cython_runtime_dict;
-#endif
-    if (unlikely(!__pyx_cython_runtime)) {
-        return c_line;
-    }
-    __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
-#if CYTHON_COMPILING_IN_CPYTHON
-    cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
-    if (likely(cython_runtime_dict)) {
-        __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
-            use_cline, *cython_runtime_dict,
-            __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback))
-    } else
-#endif
-    {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
-      if (use_cline_obj) {
-        use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
-        Py_DECREF(use_cline_obj);
-      } else {
-        PyErr_Clear();
-        use_cline = NULL;
-      }
-    }
-    if (!use_cline) {
-        c_line = 0;
-        PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False);
-    }
-    else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
-        c_line = 0;
-    }
-    __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
-    return c_line;
-}
-#endif
-
-/* CodeObjectCache */
-static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
-    int start = 0, mid = 0, end = count - 1;
-    if (end >= 0 && code_line > entries[end].code_line) {
-        return count;
-    }
-    while (start < end) {
-        mid = start + (end - start) / 2;
-        if (code_line < entries[mid].code_line) {
-            end = mid;
-        } else if (code_line > entries[mid].code_line) {
-             start = mid + 1;
-        } else {
-            return mid;
-        }
-    }
-    if (code_line <= entries[mid].code_line) {
-        return mid;
-    } else {
-        return mid + 1;
-    }
-}
-static PyCodeObject *__pyx_find_code_object(int code_line) {
-    PyCodeObject* code_object;
-    int pos;
-    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
-        return NULL;
-    }
-    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
-    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
-        return NULL;
-    }
-    code_object = __pyx_code_cache.entries[pos].code_object;
-    Py_INCREF(code_object);
-    return code_object;
-}
-static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
-    int pos, i;
-    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
-    if (unlikely(!code_line)) {
-        return;
-    }
-    if (unlikely(!entries)) {
-        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
-        if (likely(entries)) {
-            __pyx_code_cache.entries = entries;
-            __pyx_code_cache.max_count = 64;
-            __pyx_code_cache.count = 1;
-            entries[0].code_line = code_line;
-            entries[0].code_object = code_object;
-            Py_INCREF(code_object);
-        }
-        return;
-    }
-    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
-    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
-        PyCodeObject* tmp = entries[pos].code_object;
-        entries[pos].code_object = code_object;
-        Py_DECREF(tmp);
-        return;
-    }
-    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
-        int new_max = __pyx_code_cache.max_count + 64;
-        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
-            __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));
-        if (unlikely(!entries)) {
-            return;
-        }
-        __pyx_code_cache.entries = entries;
-        __pyx_code_cache.max_count = new_max;
-    }
-    for (i=__pyx_code_cache.count; i>pos; i--) {
-        entries[i] = entries[i-1];
-    }
-    entries[pos].code_line = code_line;
-    entries[pos].code_object = code_object;
-    __pyx_code_cache.count++;
-    Py_INCREF(code_object);
-}
-
-/* AddTraceback */
-#include "compile.h"
-#include "frameobject.h"
-#include "traceback.h"
-static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
-            const char *funcname, int c_line,
-            int py_line, const char *filename) {
-    PyCodeObject *py_code = 0;
-    PyObject *py_srcfile = 0;
-    PyObject *py_funcname = 0;
-    #if PY_MAJOR_VERSION < 3
-    py_srcfile = PyString_FromString(filename);
-    #else
-    py_srcfile = PyUnicode_FromString(filename);
-    #endif
-    if (!py_srcfile) goto bad;
-    if (c_line) {
-        #if PY_MAJOR_VERSION < 3
-        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
-        #else
-        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
-        #endif
-    }
-    else {
-        #if PY_MAJOR_VERSION < 3
-        py_funcname = PyString_FromString(funcname);
-        #else
-        py_funcname = PyUnicode_FromString(funcname);
-        #endif
-    }
-    if (!py_funcname) goto bad;
-    py_code = __Pyx_PyCode_New(
-        0,
-        0,
-        0,
-        0,
-        0,
-        __pyx_empty_bytes, /*PyObject *code,*/
-        __pyx_empty_tuple, /*PyObject *consts,*/
-        __pyx_empty_tuple, /*PyObject *names,*/
-        __pyx_empty_tuple, /*PyObject *varnames,*/
-        __pyx_empty_tuple, /*PyObject *freevars,*/
-        __pyx_empty_tuple, /*PyObject *cellvars,*/
-        py_srcfile,   /*PyObject *filename,*/
-        py_funcname,  /*PyObject *name,*/
-        py_line,
-        __pyx_empty_bytes  /*PyObject *lnotab*/
-    );
-    Py_DECREF(py_srcfile);
-    Py_DECREF(py_funcname);
-    return py_code;
-bad:
-    Py_XDECREF(py_srcfile);
-    Py_XDECREF(py_funcname);
-    return NULL;
-}
-static void __Pyx_AddTraceback(const char *funcname, int c_line,
-                               int py_line, const char *filename) {
-    PyCodeObject *py_code = 0;
-    PyFrameObject *py_frame = 0;
-    PyThreadState *tstate = __Pyx_PyThreadState_Current;
-    if (c_line) {
-        c_line = __Pyx_CLineForTraceback(tstate, c_line);
-    }
-    py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
-    if (!py_code) {
-        py_code = __Pyx_CreateCodeObjectForTraceback(
-            funcname, c_line, py_line, filename);
-        if (!py_code) goto bad;
-        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
-    }
-    py_frame = PyFrame_New(
-        tstate,            /*PyThreadState *tstate,*/
-        py_code,           /*PyCodeObject *code,*/
-        __pyx_d,    /*PyObject *globals,*/
-        0                  /*PyObject *locals*/
-    );
-    if (!py_frame) goto bad;
-    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
-    PyTraceBack_Here(py_frame);
-bad:
-    Py_XDECREF(py_code);
-    Py_XDECREF(py_frame);
-}
-
-#if PY_MAJOR_VERSION < 3
-static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
-    if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
-        if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags);
-        if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags);
-    PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name);
-    return -1;
-}
-static void __Pyx_ReleaseBuffer(Py_buffer *view) {
-    PyObject *obj = view->obj;
-    if (!obj) return;
-    if (PyObject_CheckBuffer(obj)) {
-        PyBuffer_Release(view);
-        return;
-    }
-    if ((0)) {}
-    view->obj = NULL;
-    Py_DECREF(obj);
-}
-#endif
-
-
-/* MemviewSliceIsContig */
-static int
-__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim)
-{
-    int i, index, step, start;
-    Py_ssize_t itemsize = mvs.memview->view.itemsize;
-    if (order == 'F') {
-        step = 1;
-        start = 0;
-    } else {
-        step = -1;
-        start = ndim - 1;
-    }
-    for (i = 0; i < ndim; i++) {
-        index = start + step * i;
-        if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize)
-            return 0;
-        itemsize *= mvs.shape[index];
-    }
-    return 1;
-}
-
-/* OverlappingSlices */
-static void
-__pyx_get_array_memory_extents(__Pyx_memviewslice *slice,
-                               void **out_start, void **out_end,
-                               int ndim, size_t itemsize)
-{
-    char *start, *end;
-    int i;
-    start = end = slice->data;
-    for (i = 0; i < ndim; i++) {
-        Py_ssize_t stride = slice->strides[i];
-        Py_ssize_t extent = slice->shape[i];
-        if (extent == 0) {
-            *out_start = *out_end = start;
-            return;
-        } else {
-            if (stride > 0)
-                end += stride * (extent - 1);
-            else
-                start += stride * (extent - 1);
-        }
-    }
-    *out_start = start;
-    *out_end = end + itemsize;
-}
-static int
-__pyx_slices_overlap(__Pyx_memviewslice *slice1,
-                     __Pyx_memviewslice *slice2,
-                     int ndim, size_t itemsize)
-{
-    void *start1, *end1, *start2, *end2;
-    __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize);
-    __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize);
-    return (start1 < end2) && (start2 < end1);
-}
-
-/* Capsule */
-static CYTHON_INLINE PyObject *
-__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig)
-{
-    PyObject *cobj;
-#if PY_VERSION_HEX >= 0x02070000
-    cobj = PyCapsule_New(p, sig, NULL);
-#else
-    cobj = PyCObject_FromVoidPtr(p, NULL);
-#endif
-    return cobj;
-}
-
-/* IsLittleEndian */
-static CYTHON_INLINE int __Pyx_Is_Little_Endian(void)
-{
-  union {
-    uint32_t u32;
-    uint8_t u8[4];
-  } S;
-  S.u32 = 0x01020304;
-  return S.u8[0] == 4;
-}
-
-/* BufferFormatCheck */
-static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
-                              __Pyx_BufFmt_StackElem* stack,
-                              __Pyx_TypeInfo* type) {
-  stack[0].field = &ctx->root;
-  stack[0].parent_offset = 0;
-  ctx->root.type = type;
-  ctx->root.name = "buffer dtype";
-  ctx->root.offset = 0;
-  ctx->head = stack;
-  ctx->head->field = &ctx->root;
-  ctx->fmt_offset = 0;
-  ctx->head->parent_offset = 0;
-  ctx->new_packmode = '@';
-  ctx->enc_packmode = '@';
-  ctx->new_count = 1;
-  ctx->enc_count = 0;
-  ctx->enc_type = 0;
-  ctx->is_complex = 0;
-  ctx->is_valid_array = 0;
-  ctx->struct_alignment = 0;
-  while (type->typegroup == 'S') {
-    ++ctx->head;
-    ctx->head->field = type->fields;
-    ctx->head->parent_offset = 0;
-    type = type->fields->type;
-  }
-}
-static int __Pyx_BufFmt_ParseNumber(const char** ts) {
-    int count;
-    const char* t = *ts;
-    if (*t < '0' || *t > '9') {
-      return -1;
-    } else {
-        count = *t++ - '0';
-        while (*t >= '0' && *t <= '9') {
-            count *= 10;
-            count += *t++ - '0';
-        }
-    }
-    *ts = t;
-    return count;
-}
-static int __Pyx_BufFmt_ExpectNumber(const char **ts) {
-    int number = __Pyx_BufFmt_ParseNumber(ts);
-    if (number == -1)
-        PyErr_Format(PyExc_ValueError,\
-                     "Does not understand character buffer dtype format string ('%c')", **ts);
-    return number;
-}
-static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) {
-  PyErr_Format(PyExc_ValueError,
-               "Unexpected format string character: '%c'", ch);
-}
-static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) {
-  switch (ch) {
-    case '?': return "'bool'";
-    case 'c': return "'char'";
-    case 'b': return "'signed char'";
-    case 'B': return "'unsigned char'";
-    case 'h': return "'short'";
-    case 'H': return "'unsigned short'";
-    case 'i': return "'int'";
-    case 'I': return "'unsigned int'";
-    case 'l': return "'long'";
-    case 'L': return "'unsigned long'";
-    case 'q': return "'long long'";
-    case 'Q': return "'unsigned long long'";
-    case 'f': return (is_complex ? "'complex float'" : "'float'");
-    case 'd': return (is_complex ? "'complex double'" : "'double'");
-    case 'g': return (is_complex ? "'complex long double'" : "'long double'");
-    case 'T': return "a struct";
-    case 'O': return "Python object";
-    case 'P': return "a pointer";
-    case 's': case 'p': return "a string";
-    case 0: return "end";
-    default: return "unparseable format string";
-  }
-}
-static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) {
-  switch (ch) {
-    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
-    case 'h': case 'H': return 2;
-    case 'i': case 'I': case 'l': case 'L': return 4;
-    case 'q': case 'Q': return 8;
-    case 'f': return (is_complex ? 8 : 4);
-    case 'd': return (is_complex ? 16 : 8);
-    case 'g': {
-      PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g')..");
-      return 0;
-    }
-    case 'O': case 'P': return sizeof(void*);
-    default:
-      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
-      return 0;
-    }
-}
-static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) {
-  switch (ch) {
-    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
-    case 'h': case 'H': return sizeof(short);
-    case 'i': case 'I': return sizeof(int);
-    case 'l': case 'L': return sizeof(long);
-    #ifdef HAVE_LONG_LONG
-    case 'q': case 'Q': return sizeof(PY_LONG_LONG);
-    #endif
-    case 'f': return sizeof(float) * (is_complex ? 2 : 1);
-    case 'd': return sizeof(double) * (is_complex ? 2 : 1);
-    case 'g': return sizeof(long double) * (is_complex ? 2 : 1);
-    case 'O': case 'P': return sizeof(void*);
-    default: {
-      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
-      return 0;
-    }
-  }
-}
-typedef struct { char c; short x; } __Pyx_st_short;
-typedef struct { char c; int x; } __Pyx_st_int;
-typedef struct { char c; long x; } __Pyx_st_long;
-typedef struct { char c; float x; } __Pyx_st_float;
-typedef struct { char c; double x; } __Pyx_st_double;
-typedef struct { char c; long double x; } __Pyx_st_longdouble;
-typedef struct { char c; void *x; } __Pyx_st_void_p;
-#ifdef HAVE_LONG_LONG
-typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong;
-#endif
-static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) {
-  switch (ch) {
-    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
-    case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short);
-    case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int);
-    case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long);
-#ifdef HAVE_LONG_LONG
-    case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG);
-#endif
-    case 'f': return sizeof(__Pyx_st_float) - sizeof(float);
-    case 'd': return sizeof(__Pyx_st_double) - sizeof(double);
-    case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double);
-    case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*);
-    default:
-      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
-      return 0;
-    }
-}
-/* These are for computing the padding at the end of the struct to align
-   on the first member of the struct. This will probably the same as above,
-   but we don't have any guarantees.
- */
-typedef struct { short x; char c; } __Pyx_pad_short;
-typedef struct { int x; char c; } __Pyx_pad_int;
-typedef struct { long x; char c; } __Pyx_pad_long;
-typedef struct { float x; char c; } __Pyx_pad_float;
-typedef struct { double x; char c; } __Pyx_pad_double;
-typedef struct { long double x; char c; } __Pyx_pad_longdouble;
-typedef struct { void *x; char c; } __Pyx_pad_void_p;
-#ifdef HAVE_LONG_LONG
-typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong;
-#endif
-static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) {
-  switch (ch) {
-    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
-    case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short);
-    case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int);
-    case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long);
-#ifdef HAVE_LONG_LONG
-    case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG);
-#endif
-    case 'f': return sizeof(__Pyx_pad_float) - sizeof(float);
-    case 'd': return sizeof(__Pyx_pad_double) - sizeof(double);
-    case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double);
-    case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*);
-    default:
-      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
-      return 0;
-    }
-}
-static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) {
-  switch (ch) {
-    case 'c':
-        return 'H';
-    case 'b': case 'h': case 'i':
-    case 'l': case 'q': case 's': case 'p':
-        return 'I';
-    case '?': case 'B': case 'H': case 'I': case 'L': case 'Q':
-        return 'U';
-    case 'f': case 'd': case 'g':
-        return (is_complex ? 'C' : 'R');
-    case 'O':
-        return 'O';
-    case 'P':
-        return 'P';
-    default: {
-      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
-      return 0;
-    }
-  }
-}
-static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) {
-  if (ctx->head == NULL || ctx->head->field == &ctx->root) {
-    const char* expected;
-    const char* quote;
-    if (ctx->head == NULL) {
-      expected = "end";
-      quote = "";
-    } else {
-      expected = ctx->head->field->type->name;
-      quote = "'";
-    }
-    PyErr_Format(PyExc_ValueError,
-                 "Buffer dtype mismatch, expected %s%s%s but got %s",
-                 quote, expected, quote,
-                 __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex));
-  } else {
-    __Pyx_StructField* field = ctx->head->field;
-    __Pyx_StructField* parent = (ctx->head - 1)->field;
-    PyErr_Format(PyExc_ValueError,
-                 "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'",
-                 field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex),
-                 parent->type->name, field->name);
-  }
-}
-static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) {
-  char group;
-  size_t size, offset, arraysize = 1;
-  if (ctx->enc_type == 0) return 0;
-  if (ctx->head->field->type->arraysize[0]) {
-    int i, ndim = 0;
-    if (ctx->enc_type == 's' || ctx->enc_type == 'p') {
-        ctx->is_valid_array = ctx->head->field->type->ndim == 1;
-        ndim = 1;
-        if (ctx->enc_count != ctx->head->field->type->arraysize[0]) {
-            PyErr_Format(PyExc_ValueError,
-                         "Expected a dimension of size %zu, got %zu",
-                         ctx->head->field->type->arraysize[0], ctx->enc_count);
-            return -1;
-        }
-    }
-    if (!ctx->is_valid_array) {
-      PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d",
-                   ctx->head->field->type->ndim, ndim);
-      return -1;
-    }
-    for (i = 0; i < ctx->head->field->type->ndim; i++) {
-      arraysize *= ctx->head->field->type->arraysize[i];
-    }
-    ctx->is_valid_array = 0;
-    ctx->enc_count = 1;
-  }
-  group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex);
-  do {
-    __Pyx_StructField* field = ctx->head->field;
-    __Pyx_TypeInfo* type = field->type;
-    if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') {
-      size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex);
-    } else {
-      size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex);
-    }
-    if (ctx->enc_packmode == '@') {
-      size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex);
-      size_t align_mod_offset;
-      if (align_at == 0) return -1;
-      align_mod_offset = ctx->fmt_offset % align_at;
-      if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset;
-      if (ctx->struct_alignment == 0)
-          ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type,
-                                                                 ctx->is_complex);
-    }
-    if (type->size != size || type->typegroup != group) {
-      if (type->typegroup == 'C' && type->fields != NULL) {
-        size_t parent_offset = ctx->head->parent_offset + field->offset;
-        ++ctx->head;
-        ctx->head->field = type->fields;
-        ctx->head->parent_offset = parent_offset;
-        continue;
-      }
-      if ((type->typegroup == 'H' || group == 'H') && type->size == size) {
-      } else {
-          __Pyx_BufFmt_RaiseExpected(ctx);
-          return -1;
-      }
-    }
-    offset = ctx->head->parent_offset + field->offset;
-    if (ctx->fmt_offset != offset) {
-      PyErr_Format(PyExc_ValueError,
-                   "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected",
-                   (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset);
-      return -1;
-    }
-    ctx->fmt_offset += size;
-    if (arraysize)
-      ctx->fmt_offset += (arraysize - 1) * size;
-    --ctx->enc_count;
-    while (1) {
-      if (field == &ctx->root) {
-        ctx->head = NULL;
-        if (ctx->enc_count != 0) {
-          __Pyx_BufFmt_RaiseExpected(ctx);
-          return -1;
-        }
-        break;
-      }
-      ctx->head->field = ++field;
-      if (field->type == NULL) {
-        --ctx->head;
-        field = ctx->head->field;
-        continue;
-      } else if (field->type->typegroup == 'S') {
-        size_t parent_offset = ctx->head->parent_offset + field->offset;
-        if (field->type->fields->type == NULL) continue;
-        field = field->type->fields;
-        ++ctx->head;
-        ctx->head->field = field;
-        ctx->head->parent_offset = parent_offset;
-        break;
-      } else {
-        break;
-      }
-    }
-  } while (ctx->enc_count);
-  ctx->enc_type = 0;
-  ctx->is_complex = 0;
-  return 0;
-}
-static PyObject *
-__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
-{
-    const char *ts = *tsp;
-    int i = 0, number, ndim;
-    ++ts;
-    if (ctx->new_count != 1) {
-        PyErr_SetString(PyExc_ValueError,
-                        "Cannot handle repeated arrays in format string");
-        return NULL;
-    }
-    if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
-    ndim = ctx->head->field->type->ndim;
-    while (*ts && *ts != ')') {
-        switch (*ts) {
-            case ' ': case '\f': case '\r': case '\n': case '\t': case '\v':  continue;
-            default:  break;
-        }
-        number = __Pyx_BufFmt_ExpectNumber(&ts);
-        if (number == -1) return NULL;
-        if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i])
-            return PyErr_Format(PyExc_ValueError,
-                        "Expected a dimension of size %zu, got %d",
-                        ctx->head->field->type->arraysize[i], number);
-        if (*ts != ',' && *ts != ')')
-            return PyErr_Format(PyExc_ValueError,
-                                "Expected a comma in format string, got '%c'", *ts);
-        if (*ts == ',') ts++;
-        i++;
-    }
-    if (i != ndim)
-        return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d",
-                            ctx->head->field->type->ndim, i);
-    if (!*ts) {
-        PyErr_SetString(PyExc_ValueError,
-                        "Unexpected end of format string, expected ')'");
-        return NULL;
-    }
-    ctx->is_valid_array = 1;
-    ctx->new_count = 1;
-    *tsp = ++ts;
-    return Py_None;
-}
-static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) {
-  int got_Z = 0;
-  while (1) {
-    switch(*ts) {
-      case 0:
-        if (ctx->enc_type != 0 && ctx->head == NULL) {
-          __Pyx_BufFmt_RaiseExpected(ctx);
-          return NULL;
-        }
-        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
-        if (ctx->head != NULL) {
-          __Pyx_BufFmt_RaiseExpected(ctx);
-          return NULL;
-        }
-        return ts;
-      case ' ':
-      case '\r':
-      case '\n':
-        ++ts;
-        break;
-      case '<':
-        if (!__Pyx_Is_Little_Endian()) {
-          PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler");
-          return NULL;
-        }
-        ctx->new_packmode = '=';
-        ++ts;
-        break;
-      case '>':
-      case '!':
-        if (__Pyx_Is_Little_Endian()) {
-          PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler");
-          return NULL;
-        }
-        ctx->new_packmode = '=';
-        ++ts;
-        break;
-      case '=':
-      case '@':
-      case '^':
-        ctx->new_packmode = *ts++;
-        break;
-      case 'T':
-        {
-          const char* ts_after_sub;
-          size_t i, struct_count = ctx->new_count;
-          size_t struct_alignment = ctx->struct_alignment;
-          ctx->new_count = 1;
-          ++ts;
-          if (*ts != '{') {
-            PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'");
-            return NULL;
-          }
-          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
-          ctx->enc_type = 0;
-          ctx->enc_count = 0;
-          ctx->struct_alignment = 0;
-          ++ts;
-          ts_after_sub = ts;
-          for (i = 0; i != struct_count; ++i) {
-            ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts);
-            if (!ts_after_sub) return NULL;
-          }
-          ts = ts_after_sub;
-          if (struct_alignment) ctx->struct_alignment = struct_alignment;
-        }
-        break;
-      case '}':
-        {
-          size_t alignment = ctx->struct_alignment;
-          ++ts;
-          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
-          ctx->enc_type = 0;
-          if (alignment && ctx->fmt_offset % alignment) {
-            ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment);
-          }
-        }
-        return ts;
-      case 'x':
-        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
-        ctx->fmt_offset += ctx->new_count;
-        ctx->new_count = 1;
-        ctx->enc_count = 0;
-        ctx->enc_type = 0;
-        ctx->enc_packmode = ctx->new_packmode;
-        ++ts;
-        break;
-      case 'Z':
-        got_Z = 1;
-        ++ts;
-        if (*ts != 'f' && *ts != 'd' && *ts != 'g') {
-          __Pyx_BufFmt_RaiseUnexpectedChar('Z');
-          return NULL;
-        }
-        CYTHON_FALLTHROUGH;
-      case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I':
-      case 'l': case 'L': case 'q': case 'Q':
-      case 'f': case 'd': case 'g':
-      case 'O': case 'p':
-        if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) &&
-            (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) {
-          ctx->enc_count += ctx->new_count;
-          ctx->new_count = 1;
-          got_Z = 0;
-          ++ts;
-          break;
-        }
-        CYTHON_FALLTHROUGH;
-      case 's':
-        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
-        ctx->enc_count = ctx->new_count;
-        ctx->enc_packmode = ctx->new_packmode;
-        ctx->enc_type = *ts;
-        ctx->is_complex = got_Z;
-        ++ts;
-        ctx->new_count = 1;
-        got_Z = 0;
-        break;
-      case ':':
-        ++ts;
-        while(*ts != ':') ++ts;
-        ++ts;
-        break;
-      case '(':
-        if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL;
-        break;
-      default:
-        {
-          int number = __Pyx_BufFmt_ExpectNumber(&ts);
-          if (number == -1) return NULL;
-          ctx->new_count = (size_t)number;
-        }
-    }
-  }
-}
-
-/* TypeInfoCompare */
-  static int
-__pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b)
-{
-    int i;
-    if (!a || !b)
-        return 0;
-    if (a == b)
-        return 1;
-    if (a->size != b->size || a->typegroup != b->typegroup ||
-            a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) {
-        if (a->typegroup == 'H' || b->typegroup == 'H') {
-            return a->size == b->size;
-        } else {
-            return 0;
-        }
-    }
-    if (a->ndim) {
-        for (i = 0; i < a->ndim; i++)
-            if (a->arraysize[i] != b->arraysize[i])
-                return 0;
-    }
-    if (a->typegroup == 'S') {
-        if (a->flags != b->flags)
-            return 0;
-        if (a->fields || b->fields) {
-            if (!(a->fields && b->fields))
-                return 0;
-            for (i = 0; a->fields[i].type && b->fields[i].type; i++) {
-                __Pyx_StructField *field_a = a->fields + i;
-                __Pyx_StructField *field_b = b->fields + i;
-                if (field_a->offset != field_b->offset ||
-                    !__pyx_typeinfo_cmp(field_a->type, field_b->type))
-                    return 0;
-            }
-            return !a->fields[i].type && !b->fields[i].type;
-        }
-    }
-    return 1;
-}
-
-/* MemviewSliceValidateAndInit */
-  static int
-__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec)
-{
-    if (buf->shape[dim] <= 1)
-        return 1;
-    if (buf->strides) {
-        if (spec & __Pyx_MEMVIEW_CONTIG) {
-            if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) {
-                if (unlikely(buf->strides[dim] != sizeof(void *))) {
-                    PyErr_Format(PyExc_ValueError,
-                                 "Buffer is not indirectly contiguous "
-                                 "in dimension %d.", dim);
-                    goto fail;
-                }
-            } else if (unlikely(buf->strides[dim] != buf->itemsize)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "Buffer and memoryview are not contiguous "
-                                "in the same dimension.");
-                goto fail;
-            }
-        }
-        if (spec & __Pyx_MEMVIEW_FOLLOW) {
-            Py_ssize_t stride = buf->strides[dim];
-            if (stride < 0)
-                stride = -stride;
-            if (unlikely(stride < buf->itemsize)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "Buffer and memoryview are not contiguous "
-                                "in the same dimension.");
-                goto fail;
-            }
-        }
-    } else {
-        if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) {
-            PyErr_Format(PyExc_ValueError,
-                         "C-contiguous buffer is not contiguous in "
-                         "dimension %d", dim);
-            goto fail;
-        } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) {
-            PyErr_Format(PyExc_ValueError,
-                         "C-contiguous buffer is not indirect in "
-                         "dimension %d", dim);
-            goto fail;
-        } else if (unlikely(buf->suboffsets)) {
-            PyErr_SetString(PyExc_ValueError,
-                            "Buffer exposes suboffsets but no strides");
-            goto fail;
-        }
-    }
-    return 1;
-fail:
-    return 0;
-}
-static int
-__pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec)
-{
-    if (spec & __Pyx_MEMVIEW_DIRECT) {
-        if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) {
-            PyErr_Format(PyExc_ValueError,
-                         "Buffer not compatible with direct access "
-                         "in dimension %d.", dim);
-            goto fail;
-        }
-    }
-    if (spec & __Pyx_MEMVIEW_PTR) {
-        if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) {
-            PyErr_Format(PyExc_ValueError,
-                         "Buffer is not indirectly accessible "
-                         "in dimension %d.", dim);
-            goto fail;
-        }
-    }
-    return 1;
-fail:
-    return 0;
-}
-static int
-__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag)
-{
-    int i;
-    if (c_or_f_flag & __Pyx_IS_F_CONTIG) {
-        Py_ssize_t stride = 1;
-        for (i = 0; i < ndim; i++) {
-            if (unlikely(stride * buf->itemsize != buf->strides[i]  &&  buf->shape[i] > 1)) {
-                PyErr_SetString(PyExc_ValueError,
-                    "Buffer not fortran contiguous.");
-                goto fail;
-            }
-            stride = stride * buf->shape[i];
-        }
-    } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) {
-        Py_ssize_t stride = 1;
-        for (i = ndim - 1; i >- 1; i--) {
-            if (unlikely(stride * buf->itemsize != buf->strides[i]  &&  buf->shape[i] > 1)) {
-                PyErr_SetString(PyExc_ValueError,
-                    "Buffer not C contiguous.");
-                goto fail;
-            }
-            stride = stride * buf->shape[i];
-        }
-    }
-    return 1;
-fail:
-    return 0;
-}
-static int __Pyx_ValidateAndInit_memviewslice(
-                int *axes_specs,
-                int c_or_f_flag,
-                int buf_flags,
-                int ndim,
-                __Pyx_TypeInfo *dtype,
-                __Pyx_BufFmt_StackElem stack[],
-                __Pyx_memviewslice *memviewslice,
-                PyObject *original_obj)
-{
-    struct __pyx_memoryview_obj *memview, *new_memview;
-    __Pyx_RefNannyDeclarations
-    Py_buffer *buf;
-    int i, spec = 0, retval = -1;
-    __Pyx_BufFmt_Context ctx;
-    int from_memoryview = __pyx_memoryview_check(original_obj);
-    __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0);
-    if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *)
-                                                            original_obj)->typeinfo)) {
-        memview = (struct __pyx_memoryview_obj *) original_obj;
-        new_memview = NULL;
-    } else {
-        memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new(
-                                            original_obj, buf_flags, 0, dtype);
-        new_memview = memview;
-        if (unlikely(!memview))
-            goto fail;
-    }
-    buf = &memview->view;
-    if (unlikely(buf->ndim != ndim)) {
-        PyErr_Format(PyExc_ValueError,
-                "Buffer has wrong number of dimensions (expected %d, got %d)",
-                ndim, buf->ndim);
-        goto fail;
-    }
-    if (new_memview) {
-        __Pyx_BufFmt_Init(&ctx, stack, dtype);
-        if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail;
-    }
-    if (unlikely((unsigned) buf->itemsize != dtype->size)) {
-        PyErr_Format(PyExc_ValueError,
-                     "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) "
-                     "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)",
-                     buf->itemsize,
-                     (buf->itemsize > 1) ? "s" : "",
-                     dtype->name,
-                     dtype->size,
-                     (dtype->size > 1) ? "s" : "");
-        goto fail;
-    }
-    if (buf->len > 0) {
-        for (i = 0; i < ndim; i++) {
-            spec = axes_specs[i];
-            if (unlikely(!__pyx_check_strides(buf, i, ndim, spec)))
-                goto fail;
-            if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec)))
-                goto fail;
-        }
-        if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag)))
-            goto fail;
-    }
-    if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice,
-                                         new_memview != NULL) == -1)) {
-        goto fail;
-    }
-    retval = 0;
-    goto no_fail;
-fail:
-    Py_XDECREF(new_memview);
-    retval = -1;
-no_fail:
-    __Pyx_RefNannyFinishContext();
-    return retval;
-}
-
-/* ObjectToMemviewSlice */
-  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_int(PyObject *obj, int writable_flag) {
-    __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } };
-    __Pyx_BufFmt_StackElem stack[1];
-    int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) };
-    int retcode;
-    if (obj == Py_None) {
-        result.memview = (struct __pyx_memoryview_obj *) Py_None;
-        return result;
-    }
-    retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG,
-                                                 (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 3,
-                                                 &__Pyx_TypeInfo_int, stack,
-                                                 &result, obj);
-    if (unlikely(retcode == -1))
-        goto __pyx_fail;
-    return result;
-__pyx_fail:
-    result.memview = NULL;
-    result.data = NULL;
-    return result;
-}
-
-/* ObjectToMemviewSlice */
-  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_float(PyObject *obj, int writable_flag) {
-    __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } };
-    __Pyx_BufFmt_StackElem stack[1];
-    int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) };
-    int retcode;
-    if (obj == Py_None) {
-        result.memview = (struct __pyx_memoryview_obj *) Py_None;
-        return result;
-    }
-    retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG,
-                                                 (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 3,
-                                                 &__Pyx_TypeInfo_float, stack,
-                                                 &result, obj);
-    if (unlikely(retcode == -1))
-        goto __pyx_fail;
-    return result;
-__pyx_fail:
-    result.memview = NULL;
-    result.data = NULL;
-    return result;
-}
-
-/* ObjectToMemviewSlice */
-  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *obj, int writable_flag) {
-    __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } };
-    __Pyx_BufFmt_StackElem stack[1];
-    int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) };
-    int retcode;
-    if (obj == Py_None) {
-        result.memview = (struct __pyx_memoryview_obj *) Py_None;
-        return result;
-    }
-    retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG,
-                                                 (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1,
-                                                 &__Pyx_TypeInfo_int, stack,
-                                                 &result, obj);
-    if (unlikely(retcode == -1))
-        goto __pyx_fail;
-    return result;
-__pyx_fail:
-    result.memview = NULL;
-    result.data = NULL;
-    return result;
-}
-
-/* CIntToPy */
-  static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
-    const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0;
-    const int is_unsigned = neg_one > const_zero;
-    if (is_unsigned) {
-        if (sizeof(int) < sizeof(long)) {
-            return PyInt_FromLong((long) value);
-        } else if (sizeof(int) <= sizeof(unsigned long)) {
-            return PyLong_FromUnsignedLong((unsigned long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
-#endif
-        }
-    } else {
-        if (sizeof(int) <= sizeof(long)) {
-            return PyInt_FromLong((long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-            return PyLong_FromLongLong((PY_LONG_LONG) value);
-#endif
-        }
-    }
-    {
-        int one = 1; int little = (int)*(unsigned char *)&one;
-        unsigned char *bytes = (unsigned char *)&value;
-        return _PyLong_FromByteArray(bytes, sizeof(int),
-                                     little, !is_unsigned);
-    }
-}
-
-/* CIntFromPyVerify */
-  #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
-    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
-#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
-    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
-#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
-    {\
-        func_type value = func_value;\
-        if (sizeof(target_type) < sizeof(func_type)) {\
-            if (unlikely(value != (func_type) (target_type) value)) {\
-                func_type zero = 0;\
-                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
-                    return (target_type) -1;\
-                if (is_unsigned && unlikely(value < zero))\
-                    goto raise_neg_overflow;\
-                else\
-                    goto raise_overflow;\
-            }\
-        }\
-        return (target_type) value;\
-    }
-
-/* CIntToPy */
-  static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
-    const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0;
-    const int is_unsigned = neg_one > const_zero;
-    if (is_unsigned) {
-        if (sizeof(long) < sizeof(long)) {
-            return PyInt_FromLong((long) value);
-        } else if (sizeof(long) <= sizeof(unsigned long)) {
-            return PyLong_FromUnsignedLong((unsigned long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
-#endif
-        }
-    } else {
-        if (sizeof(long) <= sizeof(long)) {
-            return PyInt_FromLong((long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-            return PyLong_FromLongLong((PY_LONG_LONG) value);
-#endif
-        }
-    }
-    {
-        int one = 1; int little = (int)*(unsigned char *)&one;
-        unsigned char *bytes = (unsigned char *)&value;
-        return _PyLong_FromByteArray(bytes, sizeof(long),
-                                     little, !is_unsigned);
-    }
-}
-
-/* MemviewSliceCopyTemplate */
-  static __Pyx_memviewslice
-__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
-                                 const char *mode, int ndim,
-                                 size_t sizeof_dtype, int contig_flag,
-                                 int dtype_is_object)
-{
-    __Pyx_RefNannyDeclarations
-    int i;
-    __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } };
-    struct __pyx_memoryview_obj *from_memview = from_mvs->memview;
-    Py_buffer *buf = &from_memview->view;
-    PyObject *shape_tuple = NULL;
-    PyObject *temp_int = NULL;
-    struct __pyx_array_obj *array_obj = NULL;
-    struct __pyx_memoryview_obj *memview_obj = NULL;
-    __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0);
-    for (i = 0; i < ndim; i++) {
-        if (unlikely(from_mvs->suboffsets[i] >= 0)) {
-            PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with "
-                                           "indirect dimensions (axis %d)", i);
-            goto fail;
-        }
-    }
-    shape_tuple = PyTuple_New(ndim);
-    if (unlikely(!shape_tuple)) {
-        goto fail;
-    }
-    __Pyx_GOTREF(shape_tuple);
-    for(i = 0; i < ndim; i++) {
-        temp_int = PyInt_FromSsize_t(from_mvs->shape[i]);
-        if(unlikely(!temp_int)) {
-            goto fail;
-        } else {
-            PyTuple_SET_ITEM(shape_tuple, i, temp_int);
-            temp_int = NULL;
-        }
-    }
-    array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL);
-    if (unlikely(!array_obj)) {
-        goto fail;
-    }
-    __Pyx_GOTREF(array_obj);
-    memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new(
-                                    (PyObject *) array_obj, contig_flag,
-                                    dtype_is_object,
-                                    from_mvs->memview->typeinfo);
-    if (unlikely(!memview_obj))
-        goto fail;
-    if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0))
-        goto fail;
-    if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim,
-                                                dtype_is_object) < 0))
-        goto fail;
-    goto no_fail;
-fail:
-    __Pyx_XDECREF(new_mvs.memview);
-    new_mvs.memview = NULL;
-    new_mvs.data = NULL;
-no_fail:
-    __Pyx_XDECREF(shape_tuple);
-    __Pyx_XDECREF(temp_int);
-    __Pyx_XDECREF(array_obj);
-    __Pyx_RefNannyFinishContext();
-    return new_mvs;
-}
-
-/* CIntFromPy */
-  static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
-    const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0;
-    const int is_unsigned = neg_one > const_zero;
-#if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
-            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
-        } else {
-            long val = PyInt_AS_LONG(x);
-            if (is_unsigned && unlikely(val < 0)) {
-                goto raise_neg_overflow;
-            }
-            return (int) val;
-        }
-    } else
-#endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
-#if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
-                case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
-                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
-                        }
-                    }
-                    break;
-                case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
-                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
-                        }
-                    }
-                    break;
-                case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
-                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
-                        }
-                    }
-                    break;
-            }
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
-#else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
-#endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
-#ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
-#endif
-            }
-        } else {
-#if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
-                case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
-                        }
-                    }
-                    break;
-                case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
-                        }
-                    }
-                    break;
-                case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
-                        }
-                    }
-                    break;
-                case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
-                        }
-                    }
-                    break;
-                case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
-                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
-                        }
-                    }
-                    break;
-                case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
-                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
-                        }
-                    }
-                    break;
-            }
-#endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
-#ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
-#endif
-            }
-        }
-        {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
-                Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
-            }
-#endif
-            return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
-        return val;
-    }
-raise_overflow:
-    PyErr_SetString(PyExc_OverflowError,
-        "value too large to convert to int");
-    return (int) -1;
-raise_neg_overflow:
-    PyErr_SetString(PyExc_OverflowError,
-        "can't convert negative value to int");
-    return (int) -1;
-}
-
-/* CIntFromPy */
-  static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
-    const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0;
-    const int is_unsigned = neg_one > const_zero;
-#if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
-            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
-        } else {
-            long val = PyInt_AS_LONG(x);
-            if (is_unsigned && unlikely(val < 0)) {
-                goto raise_neg_overflow;
-            }
-            return (long) val;
-        }
-    } else
-#endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
-#if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
-                case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
-                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
-                        }
-                    }
-                    break;
-                case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
-                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
-                        }
-                    }
-                    break;
-                case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
-                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
-                        }
-                    }
-                    break;
-            }
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
-#else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
-#endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
-#ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
-#endif
-            }
-        } else {
-#if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
-                case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
-                        }
-                    }
-                    break;
-                case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
-                        }
-                    }
-                    break;
-                case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
-                        }
-                    }
-                    break;
-                case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
-                        }
-                    }
-                    break;
-                case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
-                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
-                        }
-                    }
-                    break;
-                case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
-                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
-                        }
-                    }
-                    break;
-            }
-#endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
-#ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
-#endif
-            }
-        }
-        {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
-                Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
-            }
-#endif
-            return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
-        return val;
-    }
-raise_overflow:
-    PyErr_SetString(PyExc_OverflowError,
-        "value too large to convert to long");
-    return (long) -1;
-raise_neg_overflow:
-    PyErr_SetString(PyExc_OverflowError,
-        "can't convert negative value to long");
-    return (long) -1;
-}
-
-/* CIntFromPy */
-  static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) {
-    const char neg_one = (char) ((char) 0 - (char) 1), const_zero = (char) 0;
-    const int is_unsigned = neg_one > const_zero;
-#if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_Check(x))) {
-        if (sizeof(char) < sizeof(long)) {
-            __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x))
-        } else {
-            long val = PyInt_AS_LONG(x);
-            if (is_unsigned && unlikely(val < 0)) {
-                goto raise_neg_overflow;
-            }
-            return (char) val;
-        }
-    } else
-#endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
-#if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (char) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0])
-                case 2:
-                    if (8 * sizeof(char) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) {
-                            return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
-                        }
-                    }
-                    break;
-                case 3:
-                    if (8 * sizeof(char) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) {
-                            return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
-                        }
-                    }
-                    break;
-                case 4:
-                    if (8 * sizeof(char) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) {
-                            return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
-                        }
-                    }
-                    break;
-            }
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
-#else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (char) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
-#endif
-            if (sizeof(char) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x))
-#ifdef HAVE_LONG_LONG
-            } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
-#endif
-            }
-        } else {
-#if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (char) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(char,  digit, +digits[0])
-                case -2:
-                    if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
-                            return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
-                        }
-                    }
-                    break;
-                case 2:
-                    if (8 * sizeof(char) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
-                            return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
-                        }
-                    }
-                    break;
-                case -3:
-                    if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
-                            return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
-                        }
-                    }
-                    break;
-                case 3:
-                    if (8 * sizeof(char) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
-                            return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
-                        }
-                    }
-                    break;
-                case -4:
-                    if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) {
-                            return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
-                        }
-                    }
-                    break;
-                case 4:
-                    if (8 * sizeof(char) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) {
-                            return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
-                        }
-                    }
-                    break;
-            }
-#endif
-            if (sizeof(char) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x))
-#ifdef HAVE_LONG_LONG
-            } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x))
-#endif
-            }
-        }
-        {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            char val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
-                Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
-            }
-#endif
-            return (char) -1;
-        }
-    } else {
-        char val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (char) -1;
-        val = __Pyx_PyInt_As_char(tmp);
-        Py_DECREF(tmp);
-        return val;
-    }
-raise_overflow:
-    PyErr_SetString(PyExc_OverflowError,
-        "value too large to convert to char");
-    return (char) -1;
-raise_neg_overflow:
-    PyErr_SetString(PyExc_OverflowError,
-        "can't convert negative value to char");
-    return (char) -1;
-}
-
-/* CheckBinaryVersion */
-  static int __Pyx_check_binary_version(void) {
-    char ctversion[4], rtversion[4];
-    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
-    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
-        char message[200];
-        PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
-        return PyErr_WarnEx(NULL, message, 1);
-    }
-    return 0;
-}
-
-/* InitStrings */
-  static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
-    while (t->p) {
-        #if PY_MAJOR_VERSION < 3
-        if (t->is_unicode) {
-            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
-        } else if (t->intern) {
-            *t->p = PyString_InternFromString(t->s);
-        } else {
-            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
-        }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
-        if (!*t->p)
-            return -1;
-        if (PyObject_Hash(*t->p) == -1)
-            return -1;
-        ++t;
-    }
-    return 0;
-}
-
-static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
-}
-static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
-    Py_ssize_t ignore;
-    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
-}
-#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
-#if !CYTHON_PEP393_ENABLED
-static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
-    char* defenc_c;
-    PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
-    if (!defenc) return NULL;
-    defenc_c = PyBytes_AS_STRING(defenc);
-#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-    {
-        char* end = defenc_c + PyBytes_GET_SIZE(defenc);
-        char* c;
-        for (c = defenc_c; c < end; c++) {
-            if ((unsigned char) (*c) >= 128) {
-                PyUnicode_AsASCIIString(o);
-                return NULL;
-            }
-        }
-    }
-#endif
-    *length = PyBytes_GET_SIZE(defenc);
-    return defenc_c;
-}
-#else
-static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
-    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
-#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-    if (likely(PyUnicode_IS_ASCII(o))) {
-        *length = PyUnicode_GET_LENGTH(o);
-        return PyUnicode_AsUTF8(o);
-    } else {
-        PyUnicode_AsASCIIString(o);
-        return NULL;
-    }
-#else
-    return PyUnicode_AsUTF8AndSize(o, length);
-#endif
-}
-#endif
-#endif
-static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
-#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
-    if (
-#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-            __Pyx_sys_getdefaultencoding_not_ascii &&
-#endif
-            PyUnicode_Check(o)) {
-        return __Pyx_PyUnicode_AsStringAndSize(o, length);
-    } else
-#endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
-    if (PyByteArray_Check(o)) {
-        *length = PyByteArray_GET_SIZE(o);
-        return PyByteArray_AS_STRING(o);
-    } else
-#endif
-    {
-        char* result;
-        int r = PyBytes_AsStringAndSize(o, &result, length);
-        if (unlikely(r < 0)) {
-            return NULL;
-        } else {
-            return result;
-        }
-    }
-}
-static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
-   int is_true = x == Py_True;
-   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
-   else return PyObject_IsTrue(x);
-}
-static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
-    int retval;
-    if (unlikely(!x)) return -1;
-    retval = __Pyx_PyObject_IsTrue(x);
-    Py_DECREF(x);
-    return retval;
-}
-static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
-#if PY_MAJOR_VERSION >= 3
-    if (PyLong_Check(result)) {
-        if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
-            Py_DECREF(result);
-            return NULL;
-        }
-        return result;
-    }
-#endif
-    PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
-    Py_DECREF(result);
-    return NULL;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
-#if CYTHON_USE_TYPE_SLOTS
-  PyNumberMethods *m;
-#endif
-  const char *name = NULL;
-  PyObject *res = NULL;
-#if PY_MAJOR_VERSION < 3
-  if (likely(PyInt_Check(x) || PyLong_Check(x)))
-#else
-  if (likely(PyLong_Check(x)))
-#endif
-    return __Pyx_NewRef(x);
-#if CYTHON_USE_TYPE_SLOTS
-  m = Py_TYPE(x)->tp_as_number;
-  #if PY_MAJOR_VERSION < 3
-  if (m && m->nb_int) {
-    name = "int";
-    res = m->nb_int(x);
-  }
-  else if (m && m->nb_long) {
-    name = "long";
-    res = m->nb_long(x);
-  }
-  #else
-  if (likely(m && m->nb_int)) {
-    name = "int";
-    res = m->nb_int(x);
-  }
-  #endif
-#else
-  if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
-    res = PyNumber_Int(x);
-  }
-#endif
-  if (likely(res)) {
-#if PY_MAJOR_VERSION < 3
-    if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) {
-#else
-    if (unlikely(!PyLong_CheckExact(res))) {
-#endif
-        return __Pyx_PyNumber_IntOrLongWrongResultType(res, name);
-    }
-  }
-  else if (!PyErr_Occurred()) {
-    PyErr_SetString(PyExc_TypeError,
-                    "an integer is required");
-  }
-  return res;
-}
-static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
-  Py_ssize_t ival;
-  PyObject *x;
-#if PY_MAJOR_VERSION < 3
-  if (likely(PyInt_CheckExact(b))) {
-    if (sizeof(Py_ssize_t) >= sizeof(long))
-        return PyInt_AS_LONG(b);
-    else
-        return PyInt_AsSsize_t(b);
-  }
-#endif
-  if (likely(PyLong_CheckExact(b))) {
-    #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
-    } else {
-      switch (size) {
-         case 2:
-           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
-             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
-           }
-           break;
-         case -2:
-           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
-             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
-           }
-           break;
-         case 3:
-           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
-             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
-           }
-           break;
-         case -3:
-           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
-             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
-           }
-           break;
-         case 4:
-           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
-             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
-           }
-           break;
-         case -4:
-           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
-             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
-           }
-           break;
-      }
-    }
-    #endif
-    return PyLong_AsSsize_t(b);
-  }
-  x = PyNumber_Index(b);
-  if (!x) return -1;
-  ival = PyInt_AsSsize_t(x);
-  Py_DECREF(x);
-  return ival;
-}
-static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
-  return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);
-}
-static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
-    return PyInt_FromSize_t(ival);
-}
-
-
-#endif /* Py_PYTHON_H */
diff --git a/spaces/AlbertoFH98/CastenaApp/README.md b/spaces/AlbertoFH98/CastenaApp/README.md
deleted file mode 100644
index b2b179d45de5933c212ed0fccc422d9ebe26e284..0000000000000000000000000000000000000000
--- a/spaces/AlbertoFH98/CastenaApp/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: CastenaApp
-emoji: 📈
-colorFrom: green
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.27.2
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/AlekseyKorshuk/thin-plate-spline-motion-model/frames_dataset.py b/spaces/AlekseyKorshuk/thin-plate-spline-motion-model/frames_dataset.py
deleted file mode 100644
index 2328c6a0af028518fe5412ebc75b2b8a019d77c8..0000000000000000000000000000000000000000
--- a/spaces/AlekseyKorshuk/thin-plate-spline-motion-model/frames_dataset.py
+++ /dev/null
@@ -1,173 +0,0 @@
-import os
-from skimage import io, img_as_float32
-from skimage.color import gray2rgb
-from sklearn.model_selection import train_test_split
-from imageio import mimread
-from skimage.transform import resize
-import numpy as np
-from torch.utils.data import Dataset
-from augmentation import AllAugmentationTransform
-import glob
-from functools import partial
-
-
-def read_video(name, frame_shape):
-    """
-    Read video which can be:
-      - an image of concatenated frames
-      - '.mp4' and'.gif'
-      - folder with videos
-    """
-
-    if os.path.isdir(name):
-        frames = sorted(os.listdir(name))
-        num_frames = len(frames)
-        video_array = np.array(
-            [img_as_float32(io.imread(os.path.join(name, frames[idx]))) for idx in range(num_frames)])
-    elif name.lower().endswith('.png') or name.lower().endswith('.jpg'):
-        image = io.imread(name)
-
-        if len(image.shape) == 2 or image.shape[2] == 1:
-            image = gray2rgb(image)
-
-        if image.shape[2] == 4:
-            image = image[..., :3]
-
-        image = img_as_float32(image)
-
-        video_array = np.moveaxis(image, 1, 0)
-
-        video_array = video_array.reshape((-1,) + frame_shape)
-        video_array = np.moveaxis(video_array, 1, 2)
-    elif name.lower().endswith('.gif') or name.lower().endswith('.mp4') or name.lower().endswith('.mov'):
-        video = mimread(name)
-        if len(video[0].shape) == 2:
-            video = [gray2rgb(frame) for frame in video]
-        if frame_shape is not None:
-            video = np.array([resize(frame, frame_shape) for frame in video])
-        video = np.array(video)
-        if video.shape[-1] == 4:
-            video = video[..., :3]
-        video_array = img_as_float32(video)
-    else:
-        raise Exception("Unknown file extensions  %s" % name)
-
-    return video_array
-
-
-class FramesDataset(Dataset):
-    """
-    Dataset of videos, each video can be represented as:
-      - an image of concatenated frames
-      - '.mp4' or '.gif'
-      - folder with all frames
-    """
-
-    def __init__(self, root_dir, frame_shape=(256, 256, 3), id_sampling=False, is_train=True,
-                 random_seed=0, pairs_list=None, augmentation_params=None):
-        self.root_dir = root_dir
-        self.videos = os.listdir(root_dir)
-        self.frame_shape = frame_shape
-        print(self.frame_shape)
-        self.pairs_list = pairs_list
-        self.id_sampling = id_sampling
-
-        if os.path.exists(os.path.join(root_dir, 'train')):
-            assert os.path.exists(os.path.join(root_dir, 'test'))
-            print("Use predefined train-test split.")
-            if id_sampling:
-                train_videos = {os.path.basename(video).split('#')[0] for video in
-                                os.listdir(os.path.join(root_dir, 'train'))}
-                train_videos = list(train_videos)
-            else:
-                train_videos = os.listdir(os.path.join(root_dir, 'train'))
-            test_videos = os.listdir(os.path.join(root_dir, 'test'))
-            self.root_dir = os.path.join(self.root_dir, 'train' if is_train else 'test')
-        else:
-            print("Use random train-test split.")
-            train_videos, test_videos = train_test_split(self.videos, random_state=random_seed, test_size=0.2)
-
-        if is_train:
-            self.videos = train_videos
-        else:
-            self.videos = test_videos
-
-        self.is_train = is_train
-
-        if self.is_train:
-            self.transform = AllAugmentationTransform(**augmentation_params)
-        else:
-            self.transform = None
-
-    def __len__(self):
-        return len(self.videos)
-
-    def __getitem__(self, idx):
-            
-        if self.is_train and self.id_sampling:   
-            name = self.videos[idx]
-            path = np.random.choice(glob.glob(os.path.join(self.root_dir, name + '*.mp4')))
-        else:
-            name = self.videos[idx]
-            path = os.path.join(self.root_dir, name)
-
-        video_name = os.path.basename(path)
-        if self.is_train and os.path.isdir(path):
-
-            frames = os.listdir(path)
-            num_frames = len(frames)
-            frame_idx = np.sort(np.random.choice(num_frames, replace=True, size=2))
-            
-            if self.frame_shape is not None:
-                resize_fn = partial(resize, output_shape=self.frame_shape)
-            else:
-                resize_fn = img_as_float32
-
-            if type(frames[0]) is bytes:
-                video_array = [resize_fn(io.imread(os.path.join(path, frames[idx].decode('utf-8')))) for idx in
-                            frame_idx]
-            else:
-                video_array = [resize_fn(io.imread(os.path.join(path, frames[idx]))) for idx in frame_idx]
-        else:
-                 
-            video_array = read_video(path, frame_shape=self.frame_shape)
-            
-            num_frames = len(video_array)
-            frame_idx = np.sort(np.random.choice(num_frames, replace=True, size=2)) if self.is_train else range(
-                num_frames)
-            video_array = video_array[frame_idx]
-            
-
-        if self.transform is not None:
-            video_array = self.transform(video_array)
-
-        out = {}
-        if self.is_train:
-            source = np.array(video_array[0], dtype='float32')
-            driving = np.array(video_array[1], dtype='float32')
-
-            out['driving'] = driving.transpose((2, 0, 1))
-            out['source'] = source.transpose((2, 0, 1))
-        else:
-            video = np.array(video_array, dtype='float32')
-            out['video'] = video.transpose((3, 0, 1, 2))
-
-        out['name'] = video_name
-        return out
-
-
-class DatasetRepeater(Dataset):
-    """
-    Pass several times over the same dataset for better i/o performance
-    """
-
-    def __init__(self, dataset, num_repeats=100):
-        self.dataset = dataset
-        self.num_repeats = num_repeats
-
-    def __len__(self):
-        return self.num_repeats * self.dataset.__len__()
-
-    def __getitem__(self, idx):
-        return self.dataset[idx % self.dataset.__len__()]
-
diff --git a/spaces/Amrrs/DragGan-Inversion/PTI/models/StyleCLIP/mapper/latent_mappers.py b/spaces/Amrrs/DragGan-Inversion/PTI/models/StyleCLIP/mapper/latent_mappers.py
deleted file mode 100644
index 63637adc9646986a3546edd19f4555a2f75a379f..0000000000000000000000000000000000000000
--- a/spaces/Amrrs/DragGan-Inversion/PTI/models/StyleCLIP/mapper/latent_mappers.py
+++ /dev/null
@@ -1,81 +0,0 @@
-import torch
-from torch import nn
-from torch.nn import Module
-
-from models.StyleCLIP.models.stylegan2.model import EqualLinear, PixelNorm
-
-
-class Mapper(Module):
-
-    def __init__(self, opts):
-        super(Mapper, self).__init__()
-
-        self.opts = opts
-        layers = [PixelNorm()]
-
-        for i in range(4):
-            layers.append(
-                EqualLinear(
-                    512, 512, lr_mul=0.01, activation='fused_lrelu'
-                )
-            )
-
-        self.mapping = nn.Sequential(*layers)
-
-
-    def forward(self, x):
-        x = self.mapping(x)
-        return x
-
-
-class SingleMapper(Module):
-
-    def __init__(self, opts):
-        super(SingleMapper, self).__init__()
-
-        self.opts = opts
-
-        self.mapping = Mapper(opts)
-
-    def forward(self, x):
-        out = self.mapping(x)
-        return out
-
-
-class LevelsMapper(Module):
-
-    def __init__(self, opts):
-        super(LevelsMapper, self).__init__()
-
-        self.opts = opts
-
-        if not opts.no_coarse_mapper:
-            self.course_mapping = Mapper(opts)
-        if not opts.no_medium_mapper:
-            self.medium_mapping = Mapper(opts)
-        if not opts.no_fine_mapper:
-            self.fine_mapping = Mapper(opts)
-
-    def forward(self, x):
-        x_coarse = x[:, :4, :]
-        x_medium = x[:, 4:8, :]
-        x_fine = x[:, 8:, :]
-
-        if not self.opts.no_coarse_mapper:
-            x_coarse = self.course_mapping(x_coarse)
-        else:
-            x_coarse = torch.zeros_like(x_coarse)
-        if not self.opts.no_medium_mapper:
-            x_medium = self.medium_mapping(x_medium)
-        else:
-            x_medium = torch.zeros_like(x_medium)
-        if not self.opts.no_fine_mapper:
-            x_fine = self.fine_mapping(x_fine)
-        else:
-            x_fine = torch.zeros_like(x_fine)
-
-
-        out = torch.cat([x_coarse, x_medium, x_fine], dim=1)
-
-        return out
-
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/optimization/fp16.md b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/optimization/fp16.md
deleted file mode 100644
index 8b3a62cba099022610c84fd9ce74fc42b6bdf75b..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/optimization/fp16.md
+++ /dev/null
@@ -1,434 +0,0 @@
-<!--Copyright 2023 The HuggingFace Team. 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.
--->
-
-# Memory and speed
-
-We present some techniques and ideas to optimize 🤗 Diffusers _inference_ for memory or speed. As a general rule, we recommend the use of [xFormers](https://github.com/facebookresearch/xformers) for memory efficient attention, please see the recommended [installation instructions](xformers).
-
-We'll discuss how the following settings impact performance and memory.
-
-|                  | Latency | Speedup |
-| ---------------- | ------- | ------- |
-| original         | 9.50s   | x1      |
-| fp16             | 3.61s   | x2.63   |
-| channels last    | 3.30s   | x2.88   |
-| traced UNet      | 3.21s   | x2.96   |
-| memory efficient attention  | 2.63s  | x3.61   |
-
-<em>
-  obtained on NVIDIA TITAN RTX by generating a single image of size 512x512 from
-  the prompt "a photo of an astronaut riding a horse on mars" with 50 DDIM
-  steps.
-</em>
-
-### Use tf32 instead of fp32 (on Ampere and later CUDA devices)
-
-On Ampere and later CUDA devices matrix multiplications and convolutions can use the TensorFloat32 (TF32) mode for faster but slightly less accurate computations. By default PyTorch enables TF32 mode for convolutions but not matrix multiplications, and unless a network requires full float32 precision we recommend enabling this setting for matrix multiplications, too. It can significantly speed up computations with typically negligible loss of numerical accuracy. You can read more about it [here](https://huggingface.co/docs/transformers/v4.18.0/en/performance#tf32). All you need to do is to add this before your inference:
-
-```python
-import torch
-
-torch.backends.cuda.matmul.allow_tf32 = True
-```
-
-## Half precision weights
-
-To save more GPU memory and get more speed, you can load and run the model weights directly in half precision. This involves loading the float16 version of the weights, which was saved to a branch named `fp16`, and telling PyTorch to use the `float16` type when loading them:
-
-```Python
-import torch
-from diffusers import DiffusionPipeline
-
-pipe = DiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-pipe = pipe.to("cuda")
-
-prompt = "a photo of an astronaut riding a horse on mars"
-image = pipe(prompt).images[0]
-```
-
-<Tip warning={true}>
-
-  It is strongly discouraged to make use of [`torch.autocast`](https://pytorch.org/docs/stable/amp.html#torch.autocast) in any of the pipelines as it can lead to black images and is always slower than using pure 
-  float16 precision.
-  
-</Tip>
-
-## Sliced attention for additional memory savings
-
-For even additional memory savings, you can use a sliced version of attention that performs the computation in steps instead of all at once.
-
-<Tip>
-  Attention slicing is useful even if a batch size of just 1 is used - as long
-  as the model uses more than one attention head. If there is more than one
-  attention head the *QK^T* attention matrix can be computed sequentially for
-  each head which can save a significant amount of memory.
-</Tip>
-
-To perform the attention computation sequentially over each head, you only need to invoke [`~DiffusionPipeline.enable_attention_slicing`] in your pipeline before inference, like here:
-
-```Python
-import torch
-from diffusers import DiffusionPipeline
-
-pipe = DiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-pipe = pipe.to("cuda")
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_attention_slicing()
-image = pipe(prompt).images[0]
-```
-
-There's a small performance penalty of about 10% slower inference times, but this method allows you to use Stable Diffusion in as little as 3.2 GB of VRAM!
-
-
-## Sliced VAE decode for larger batches
-
-To decode large batches of images with limited VRAM, or to enable batches with 32 images or more, you can use sliced VAE decode that decodes the batch latents one image at a time.
-
-You likely want to couple this with [`~StableDiffusionPipeline.enable_attention_slicing`] or [`~StableDiffusionPipeline.enable_xformers_memory_efficient_attention`] to further minimize memory use.
-
-To perform the VAE decode one image at a time, invoke [`~StableDiffusionPipeline.enable_vae_slicing`] in your pipeline before inference. For example:
-
-```Python
-import torch
-from diffusers import StableDiffusionPipeline
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-pipe = pipe.to("cuda")
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_vae_slicing()
-images = pipe([prompt] * 32).images
-```
-
-You may see a small performance boost in VAE decode on multi-image batches. There should be no performance impact on single-image batches.
-
-
-## Tiled VAE decode and encode for large images
-
-Tiled VAE processing makes it possible to work with large images on limited VRAM. For example, generating 4k images in 8GB of VRAM. Tiled VAE decoder splits the image into overlapping tiles, decodes the tiles, and blends the outputs to make the final image.
-
-You want to couple this with [`~StableDiffusionPipeline.enable_attention_slicing`] or [`~StableDiffusionPipeline.enable_xformers_memory_efficient_attention`] to further minimize memory use.
-
-To use tiled VAE processing, invoke [`~StableDiffusionPipeline.enable_vae_tiling`] in your pipeline before inference. For example:
-
-```python
-import torch
-from diffusers import StableDiffusionPipeline, UniPCMultistepScheduler
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
-pipe = pipe.to("cuda")
-prompt = "a beautiful landscape photograph"
-pipe.enable_vae_tiling()
-pipe.enable_xformers_memory_efficient_attention()
-
-image = pipe([prompt], width=3840, height=2224, num_inference_steps=20).images[0]
-```
-
-The output image will have some tile-to-tile tone variation from the tiles having separate decoders, but you shouldn't see sharp seams between the tiles. The tiling is turned off for images that are 512x512 or smaller.
-
-
-<a name="sequential_offloading"></a>
-## Offloading to CPU with accelerate for memory savings
-
-For additional memory savings, you can offload the weights to CPU and only load them to GPU when performing the forward pass.
-
-To perform CPU offloading, all you have to do is invoke [`~StableDiffusionPipeline.enable_sequential_cpu_offload`]:
-
-```Python
-import torch
-from diffusers import StableDiffusionPipeline
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_sequential_cpu_offload()
-image = pipe(prompt).images[0]
-```
-
-And you can get the memory consumption to < 3GB.
-
-Note that this method works at the submodule level, not on whole models. This is the best way to minimize memory consumption, but inference is much slower due to the iterative nature of the process. The UNet component of the pipeline runs several times (as many as `num_inference_steps`); each time, the different submodules of the UNet are sequentially onloaded and then offloaded as they are needed, so the number of memory transfers is large.
-
-<Tip>
-Consider using <a href="#model_offloading">model offloading</a> as another point in the optimization space: it will be much faster, but memory savings won't be as large.
-</Tip>
-
-It is also possible to chain offloading with attention slicing for minimal memory consumption (< 2GB).
-
-```Python
-import torch
-from diffusers import StableDiffusionPipeline
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_sequential_cpu_offload()
-pipe.enable_attention_slicing(1)
-
-image = pipe(prompt).images[0]
-```
-
-**Note**: When using `enable_sequential_cpu_offload()`, it is important to **not** move the pipeline to CUDA beforehand or else the gain in memory consumption will only be minimal. See [this issue](https://github.com/huggingface/diffusers/issues/1934) for more information.
-
-**Note**: `enable_sequential_cpu_offload()` is a stateful operation that installs hooks on the models.
-
-
-<a name="model_offloading"></a>
-## Model offloading for fast inference and memory savings
-
-[Sequential CPU offloading](#sequential_offloading), as discussed in the previous section, preserves a lot of memory but makes inference slower, because submodules are moved to GPU as needed, and immediately returned to CPU when a new module runs.
-
-Full-model offloading is an alternative that moves whole models to the GPU, instead of handling each model's constituent _modules_. This results in a negligible impact on inference time (compared with moving the pipeline to `cuda`), while still providing some memory savings.
-
-In this scenario, only one of the main components of the pipeline (typically: text encoder, unet and vae)
-will be in the GPU while the others wait in the CPU. Components like the UNet that run for multiple iterations will stay on GPU until they are no longer needed.
-
-This feature can be enabled by invoking `enable_model_cpu_offload()` on the pipeline, as shown below.
-
-```Python
-import torch
-from diffusers import StableDiffusionPipeline
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",  
-    torch_dtype=torch.float16,
-)
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_model_cpu_offload()
-image = pipe(prompt).images[0]
-```
-
-This is also compatible with attention slicing for additional memory savings.
-
-```Python
-import torch
-from diffusers import StableDiffusionPipeline
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_model_cpu_offload()
-pipe.enable_attention_slicing(1)
-
-image = pipe(prompt).images[0]
-```
-
-<Tip>
-This feature requires `accelerate` version 0.17.0 or larger.
-</Tip>
-
-**Note**: `enable_model_cpu_offload()` is a stateful operation that installs hooks on the models and state on the pipeline. In order to properly offload
-models after they are called, it is required that the entire pipeline is run and models are called in the order the pipeline expects them to be. Exercise caution
-if models are re-used outside the context of the pipeline after hooks have been installed. See [accelerate](https://huggingface.co/docs/accelerate/v0.18.0/en/package_reference/big_modeling#accelerate.hooks.remove_hook_from_module)
-for further docs on removing hooks.
-
-## Using Channels Last memory format
-
-Channels last memory format is an alternative way of ordering NCHW tensors in memory preserving dimensions ordering. Channels last tensors ordered in such a way that channels become the densest dimension (aka storing images pixel-per-pixel). Since not all operators currently support channels last format it may result in a worst performance, so it's better to try it and see if it works for your model.
-
-For example, in order to set the UNet model in our pipeline to use channels last format, we can use the following:
-
-```python
-print(pipe.unet.conv_out.state_dict()["weight"].stride())  # (2880, 9, 3, 1)
-pipe.unet.to(memory_format=torch.channels_last)  # in-place operation
-print(
-    pipe.unet.conv_out.state_dict()["weight"].stride()
-)  # (2880, 1, 960, 320) having a stride of 1 for the 2nd dimension proves that it works
-```
-
-## Tracing
-
-Tracing runs an example input tensor through your model, and captures the operations that are invoked as that input makes its way through the model's layers so that an executable or `ScriptFunction` is returned that will be optimized using just-in-time compilation.
-
-To trace our UNet model, we can use the following:
-
-```python
-import time
-import torch
-from diffusers import StableDiffusionPipeline
-import functools
-
-# torch disable grad
-torch.set_grad_enabled(False)
-
-# set variables
-n_experiments = 2
-unet_runs_per_experiment = 50
-
-
-# load inputs
-def generate_inputs():
-    sample = torch.randn(2, 4, 64, 64).half().cuda()
-    timestep = torch.rand(1).half().cuda() * 999
-    encoder_hidden_states = torch.randn(2, 77, 768).half().cuda()
-    return sample, timestep, encoder_hidden_states
-
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-).to("cuda")
-unet = pipe.unet
-unet.eval()
-unet.to(memory_format=torch.channels_last)  # use channels_last memory format
-unet.forward = functools.partial(unet.forward, return_dict=False)  # set return_dict=False as default
-
-# warmup
-for _ in range(3):
-    with torch.inference_mode():
-        inputs = generate_inputs()
-        orig_output = unet(*inputs)
-
-# trace
-print("tracing..")
-unet_traced = torch.jit.trace(unet, inputs)
-unet_traced.eval()
-print("done tracing")
-
-
-# warmup and optimize graph
-for _ in range(5):
-    with torch.inference_mode():
-        inputs = generate_inputs()
-        orig_output = unet_traced(*inputs)
-
-
-# benchmarking
-with torch.inference_mode():
-    for _ in range(n_experiments):
-        torch.cuda.synchronize()
-        start_time = time.time()
-        for _ in range(unet_runs_per_experiment):
-            orig_output = unet_traced(*inputs)
-        torch.cuda.synchronize()
-        print(f"unet traced inference took {time.time() - start_time:.2f} seconds")
-    for _ in range(n_experiments):
-        torch.cuda.synchronize()
-        start_time = time.time()
-        for _ in range(unet_runs_per_experiment):
-            orig_output = unet(*inputs)
-        torch.cuda.synchronize()
-        print(f"unet inference took {time.time() - start_time:.2f} seconds")
-
-# save the model
-unet_traced.save("unet_traced.pt")
-```
-
-Then we can replace the `unet` attribute of the pipeline with the traced model like the following
-
-```python
-from diffusers import StableDiffusionPipeline
-import torch
-from dataclasses import dataclass
-
-
-@dataclass
-class UNet2DConditionOutput:
-    sample: torch.FloatTensor
-
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-).to("cuda")
-
-# use jitted unet
-unet_traced = torch.jit.load("unet_traced.pt")
-
-
-# del pipe.unet
-class TracedUNet(torch.nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.in_channels = pipe.unet.in_channels
-        self.device = pipe.unet.device
-
-    def forward(self, latent_model_input, t, encoder_hidden_states):
-        sample = unet_traced(latent_model_input, t, encoder_hidden_states)[0]
-        return UNet2DConditionOutput(sample=sample)
-
-
-pipe.unet = TracedUNet()
-
-with torch.inference_mode():
-    image = pipe([prompt] * 1, num_inference_steps=50).images[0]
-```
-
-
-## Memory Efficient Attention
-
-Recent work on optimizing the bandwitdh in the attention block has generated huge speed ups and gains in GPU memory usage. The most recent being Flash Attention from @tridao: [code](https://github.com/HazyResearch/flash-attention), [paper](https://arxiv.org/pdf/2205.14135.pdf).
-
-Here are the speedups we obtain on a few Nvidia GPUs when running the inference at 512x512 with a batch size of 1 (one prompt):
-
-| GPU              	| Base Attention FP16 	| Memory Efficient Attention FP16 	|
-|------------------	|---------------------	|---------------------------------	|
-| NVIDIA Tesla T4  	| 3.5it/s             	| 5.5it/s                         	|
-| NVIDIA 3060 RTX  	| 4.6it/s             	| 7.8it/s                         	|
-| NVIDIA A10G      	| 8.88it/s            	| 15.6it/s                        	|
-| NVIDIA RTX A6000 	| 11.7it/s            	| 21.09it/s                       	|
-| NVIDIA TITAN RTX  | 12.51it/s         	| 18.22it/s                       	|
-| A100-SXM4-40GB    	| 18.6it/s            	| 29.it/s                        	|
-| A100-SXM-80GB    	| 18.7it/s            	| 29.5it/s                        	|
-
-To leverage it just make sure you have:
-
-<Tip warning={true}>
-
-If you have PyTorch 2.0 installed, you shouldn't use xFormers!
-
-</Tip>
-
- - PyTorch > 1.12
- - Cuda available
- - [Installed the xformers library](xformers).
-```python
-from diffusers import DiffusionPipeline
-import torch
-
-pipe = DiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-).to("cuda")
-
-pipe.enable_xformers_memory_efficient_attention()
-
-with torch.inference_mode():
-    sample = pipe("a small cat")
-
-# optional: You can disable it via
-# pipe.disable_xformers_memory_efficient_attention()
-```
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/ccnet/ccnet_r50-d8_512x1024_80k_cityscapes.py b/spaces/Andy1621/uniformer_image_segmentation/configs/ccnet/ccnet_r50-d8_512x1024_80k_cityscapes.py
deleted file mode 100644
index 16e34356e9f8566ec73e3c25c771e281d3eeb975..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/ccnet/ccnet_r50-d8_512x1024_80k_cityscapes.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = [
-    '../_base_/models/ccnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
diff --git a/spaces/Andy1621/uniformer_light/imagenet_class_index.py b/spaces/Andy1621/uniformer_light/imagenet_class_index.py
deleted file mode 100644
index 5407d1471197fd9bfa466c47d8dfb6683cb9f551..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_light/imagenet_class_index.py
+++ /dev/null
@@ -1,1002 +0,0 @@
-imagenet_classnames = {
-    "0": ["n01440764", "tench"], 
-    "1": ["n01443537", "goldfish"], 
-    "2": ["n01484850", "great_white_shark"], 
-    "3": ["n01491361", "tiger_shark"], 
-    "4": ["n01494475", "hammerhead"], 
-    "5": ["n01496331", "electric_ray"], 
-    "6": ["n01498041", "stingray"], 
-    "7": ["n01514668", "cock"], 
-    "8": ["n01514859", "hen"], 
-    "9": ["n01518878", "ostrich"], 
-    "10": ["n01530575", "brambling"], 
-    "11": ["n01531178", "goldfinch"], 
-    "12": ["n01532829", "house_finch"], 
-    "13": ["n01534433", "junco"], 
-    "14": ["n01537544", "indigo_bunting"], 
-    "15": ["n01558993", "robin"], 
-    "16": ["n01560419", "bulbul"], 
-    "17": ["n01580077", "jay"], 
-    "18": ["n01582220", "magpie"], 
-    "19": ["n01592084", "chickadee"], 
-    "20": ["n01601694", "water_ouzel"], 
-    "21": ["n01608432", "kite"], 
-    "22": ["n01614925", "bald_eagle"], 
-    "23": ["n01616318", "vulture"], 
-    "24": ["n01622779", "great_grey_owl"], 
-    "25": ["n01629819", "European_fire_salamander"], 
-    "26": ["n01630670", "common_newt"], 
-    "27": ["n01631663", "eft"], 
-    "28": ["n01632458", "spotted_salamander"], 
-    "29": ["n01632777", "axolotl"], 
-    "30": ["n01641577", "bullfrog"], 
-    "31": ["n01644373", "tree_frog"], 
-    "32": ["n01644900", "tailed_frog"], 
-    "33": ["n01664065", "loggerhead"], 
-    "34": ["n01665541", "leatherback_turtle"], 
-    "35": ["n01667114", "mud_turtle"], 
-    "36": ["n01667778", "terrapin"], 
-    "37": ["n01669191", "box_turtle"], 
-    "38": ["n01675722", "banded_gecko"], 
-    "39": ["n01677366", "common_iguana"], 
-    "40": ["n01682714", "American_chameleon"], 
-    "41": ["n01685808", "whiptail"], 
-    "42": ["n01687978", "agama"], 
-    "43": ["n01688243", "frilled_lizard"], 
-    "44": ["n01689811", "alligator_lizard"], 
-    "45": ["n01692333", "Gila_monster"], 
-    "46": ["n01693334", "green_lizard"], 
-    "47": ["n01694178", "African_chameleon"], 
-    "48": ["n01695060", "Komodo_dragon"], 
-    "49": ["n01697457", "African_crocodile"], 
-    "50": ["n01698640", "American_alligator"], 
-    "51": ["n01704323", "triceratops"], 
-    "52": ["n01728572", "thunder_snake"], 
-    "53": ["n01728920", "ringneck_snake"], 
-    "54": ["n01729322", "hognose_snake"], 
-    "55": ["n01729977", "green_snake"], 
-    "56": ["n01734418", "king_snake"], 
-    "57": ["n01735189", "garter_snake"], 
-    "58": ["n01737021", "water_snake"], 
-    "59": ["n01739381", "vine_snake"], 
-    "60": ["n01740131", "night_snake"], 
-    "61": ["n01742172", "boa_constrictor"], 
-    "62": ["n01744401", "rock_python"], 
-    "63": ["n01748264", "Indian_cobra"], 
-    "64": ["n01749939", "green_mamba"], 
-    "65": ["n01751748", "sea_snake"], 
-    "66": ["n01753488", "horned_viper"], 
-    "67": ["n01755581", "diamondback"], 
-    "68": ["n01756291", "sidewinder"], 
-    "69": ["n01768244", "trilobite"], 
-    "70": ["n01770081", "harvestman"], 
-    "71": ["n01770393", "scorpion"], 
-    "72": ["n01773157", "black_and_gold_garden_spider"], 
-    "73": ["n01773549", "barn_spider"], 
-    "74": ["n01773797", "garden_spider"], 
-    "75": ["n01774384", "black_widow"], 
-    "76": ["n01774750", "tarantula"], 
-    "77": ["n01775062", "wolf_spider"], 
-    "78": ["n01776313", "tick"], 
-    "79": ["n01784675", "centipede"], 
-    "80": ["n01795545", "black_grouse"], 
-    "81": ["n01796340", "ptarmigan"], 
-    "82": ["n01797886", "ruffed_grouse"], 
-    "83": ["n01798484", "prairie_chicken"], 
-    "84": ["n01806143", "peacock"], 
-    "85": ["n01806567", "quail"], 
-    "86": ["n01807496", "partridge"], 
-    "87": ["n01817953", "African_grey"], 
-    "88": ["n01818515", "macaw"], 
-    "89": ["n01819313", "sulphur-crested_cockatoo"], 
-    "90": ["n01820546", "lorikeet"], 
-    "91": ["n01824575", "coucal"], 
-    "92": ["n01828970", "bee_eater"], 
-    "93": ["n01829413", "hornbill"], 
-    "94": ["n01833805", "hummingbird"], 
-    "95": ["n01843065", "jacamar"], 
-    "96": ["n01843383", "toucan"], 
-    "97": ["n01847000", "drake"], 
-    "98": ["n01855032", "red-breasted_merganser"], 
-    "99": ["n01855672", "goose"], 
-    "100": ["n01860187", "black_swan"], 
-    "101": ["n01871265", "tusker"], 
-    "102": ["n01872401", "echidna"], 
-    "103": ["n01873310", "platypus"], 
-    "104": ["n01877812", "wallaby"], 
-    "105": ["n01882714", "koala"], 
-    "106": ["n01883070", "wombat"], 
-    "107": ["n01910747", "jellyfish"], 
-    "108": ["n01914609", "sea_anemone"], 
-    "109": ["n01917289", "brain_coral"], 
-    "110": ["n01924916", "flatworm"], 
-    "111": ["n01930112", "nematode"], 
-    "112": ["n01943899", "conch"], 
-    "113": ["n01944390", "snail"], 
-    "114": ["n01945685", "slug"], 
-    "115": ["n01950731", "sea_slug"], 
-    "116": ["n01955084", "chiton"], 
-    "117": ["n01968897", "chambered_nautilus"], 
-    "118": ["n01978287", "Dungeness_crab"], 
-    "119": ["n01978455", "rock_crab"], 
-    "120": ["n01980166", "fiddler_crab"], 
-    "121": ["n01981276", "king_crab"], 
-    "122": ["n01983481", "American_lobster"], 
-    "123": ["n01984695", "spiny_lobster"], 
-    "124": ["n01985128", "crayfish"], 
-    "125": ["n01986214", "hermit_crab"], 
-    "126": ["n01990800", "isopod"], 
-    "127": ["n02002556", "white_stork"], 
-    "128": ["n02002724", "black_stork"], 
-    "129": ["n02006656", "spoonbill"], 
-    "130": ["n02007558", "flamingo"], 
-    "131": ["n02009229", "little_blue_heron"], 
-    "132": ["n02009912", "American_egret"], 
-    "133": ["n02011460", "bittern"], 
-    "134": ["n02012849", "crane"], 
-    "135": ["n02013706", "limpkin"], 
-    "136": ["n02017213", "European_gallinule"], 
-    "137": ["n02018207", "American_coot"], 
-    "138": ["n02018795", "bustard"], 
-    "139": ["n02025239", "ruddy_turnstone"], 
-    "140": ["n02027492", "red-backed_sandpiper"], 
-    "141": ["n02028035", "redshank"], 
-    "142": ["n02033041", "dowitcher"], 
-    "143": ["n02037110", "oystercatcher"], 
-    "144": ["n02051845", "pelican"], 
-    "145": ["n02056570", "king_penguin"], 
-    "146": ["n02058221", "albatross"], 
-    "147": ["n02066245", "grey_whale"], 
-    "148": ["n02071294", "killer_whale"], 
-    "149": ["n02074367", "dugong"], 
-    "150": ["n02077923", "sea_lion"], 
-    "151": ["n02085620", "Chihuahua"], 
-    "152": ["n02085782", "Japanese_spaniel"], 
-    "153": ["n02085936", "Maltese_dog"], 
-    "154": ["n02086079", "Pekinese"], 
-    "155": ["n02086240", "Shih-Tzu"], 
-    "156": ["n02086646", "Blenheim_spaniel"], 
-    "157": ["n02086910", "papillon"], 
-    "158": ["n02087046", "toy_terrier"], 
-    "159": ["n02087394", "Rhodesian_ridgeback"], 
-    "160": ["n02088094", "Afghan_hound"], 
-    "161": ["n02088238", "basset"], 
-    "162": ["n02088364", "beagle"], 
-    "163": ["n02088466", "bloodhound"], 
-    "164": ["n02088632", "bluetick"], 
-    "165": ["n02089078", "black-and-tan_coonhound"], 
-    "166": ["n02089867", "Walker_hound"], 
-    "167": ["n02089973", "English_foxhound"], 
-    "168": ["n02090379", "redbone"], 
-    "169": ["n02090622", "borzoi"], 
-    "170": ["n02090721", "Irish_wolfhound"], 
-    "171": ["n02091032", "Italian_greyhound"], 
-    "172": ["n02091134", "whippet"], 
-    "173": ["n02091244", "Ibizan_hound"], 
-    "174": ["n02091467", "Norwegian_elkhound"], 
-    "175": ["n02091635", "otterhound"], 
-    "176": ["n02091831", "Saluki"], 
-    "177": ["n02092002", "Scottish_deerhound"], 
-    "178": ["n02092339", "Weimaraner"], 
-    "179": ["n02093256", "Staffordshire_bullterrier"], 
-    "180": ["n02093428", "American_Staffordshire_terrier"], 
-    "181": ["n02093647", "Bedlington_terrier"], 
-    "182": ["n02093754", "Border_terrier"], 
-    "183": ["n02093859", "Kerry_blue_terrier"], 
-    "184": ["n02093991", "Irish_terrier"], 
-    "185": ["n02094114", "Norfolk_terrier"], 
-    "186": ["n02094258", "Norwich_terrier"], 
-    "187": ["n02094433", "Yorkshire_terrier"], 
-    "188": ["n02095314", "wire-haired_fox_terrier"], 
-    "189": ["n02095570", "Lakeland_terrier"], 
-    "190": ["n02095889", "Sealyham_terrier"], 
-    "191": ["n02096051", "Airedale"], 
-    "192": ["n02096177", "cairn"], 
-    "193": ["n02096294", "Australian_terrier"], 
-    "194": ["n02096437", "Dandie_Dinmont"], 
-    "195": ["n02096585", "Boston_bull"], 
-    "196": ["n02097047", "miniature_schnauzer"], 
-    "197": ["n02097130", "giant_schnauzer"], 
-    "198": ["n02097209", "standard_schnauzer"], 
-    "199": ["n02097298", "Scotch_terrier"], 
-    "200": ["n02097474", "Tibetan_terrier"], 
-    "201": ["n02097658", "silky_terrier"], 
-    "202": ["n02098105", "soft-coated_wheaten_terrier"], 
-    "203": ["n02098286", "West_Highland_white_terrier"], 
-    "204": ["n02098413", "Lhasa"], 
-    "205": ["n02099267", "flat-coated_retriever"], 
-    "206": ["n02099429", "curly-coated_retriever"], 
-    "207": ["n02099601", "golden_retriever"], 
-    "208": ["n02099712", "Labrador_retriever"], 
-    "209": ["n02099849", "Chesapeake_Bay_retriever"], 
-    "210": ["n02100236", "German_short-haired_pointer"], 
-    "211": ["n02100583", "vizsla"], 
-    "212": ["n02100735", "English_setter"], 
-    "213": ["n02100877", "Irish_setter"], 
-    "214": ["n02101006", "Gordon_setter"], 
-    "215": ["n02101388", "Brittany_spaniel"], 
-    "216": ["n02101556", "clumber"], 
-    "217": ["n02102040", "English_springer"], 
-    "218": ["n02102177", "Welsh_springer_spaniel"], 
-    "219": ["n02102318", "cocker_spaniel"], 
-    "220": ["n02102480", "Sussex_spaniel"], 
-    "221": ["n02102973", "Irish_water_spaniel"], 
-    "222": ["n02104029", "kuvasz"], 
-    "223": ["n02104365", "schipperke"], 
-    "224": ["n02105056", "groenendael"], 
-    "225": ["n02105162", "malinois"], 
-    "226": ["n02105251", "briard"], 
-    "227": ["n02105412", "kelpie"], 
-    "228": ["n02105505", "komondor"], 
-    "229": ["n02105641", "Old_English_sheepdog"], 
-    "230": ["n02105855", "Shetland_sheepdog"], 
-    "231": ["n02106030", "collie"], 
-    "232": ["n02106166", "Border_collie"], 
-    "233": ["n02106382", "Bouvier_des_Flandres"], 
-    "234": ["n02106550", "Rottweiler"], 
-    "235": ["n02106662", "German_shepherd"], 
-    "236": ["n02107142", "Doberman"], 
-    "237": ["n02107312", "miniature_pinscher"], 
-    "238": ["n02107574", "Greater_Swiss_Mountain_dog"], 
-    "239": ["n02107683", "Bernese_mountain_dog"], 
-    "240": ["n02107908", "Appenzeller"], 
-    "241": ["n02108000", "EntleBucher"], 
-    "242": ["n02108089", "boxer"], 
-    "243": ["n02108422", "bull_mastiff"], 
-    "244": ["n02108551", "Tibetan_mastiff"], 
-    "245": ["n02108915", "French_bulldog"], 
-    "246": ["n02109047", "Great_Dane"], 
-    "247": ["n02109525", "Saint_Bernard"], 
-    "248": ["n02109961", "Eskimo_dog"], 
-    "249": ["n02110063", "malamute"], 
-    "250": ["n02110185", "Siberian_husky"], 
-    "251": ["n02110341", "dalmatian"], 
-    "252": ["n02110627", "affenpinscher"], 
-    "253": ["n02110806", "basenji"], 
-    "254": ["n02110958", "pug"], 
-    "255": ["n02111129", "Leonberg"], 
-    "256": ["n02111277", "Newfoundland"], 
-    "257": ["n02111500", "Great_Pyrenees"], 
-    "258": ["n02111889", "Samoyed"], 
-    "259": ["n02112018", "Pomeranian"], 
-    "260": ["n02112137", "chow"], 
-    "261": ["n02112350", "keeshond"], 
-    "262": ["n02112706", "Brabancon_griffon"], 
-    "263": ["n02113023", "Pembroke"], 
-    "264": ["n02113186", "Cardigan"], 
-    "265": ["n02113624", "toy_poodle"], 
-    "266": ["n02113712", "miniature_poodle"], 
-    "267": ["n02113799", "standard_poodle"], 
-    "268": ["n02113978", "Mexican_hairless"], 
-    "269": ["n02114367", "timber_wolf"], 
-    "270": ["n02114548", "white_wolf"], 
-    "271": ["n02114712", "red_wolf"], 
-    "272": ["n02114855", "coyote"], 
-    "273": ["n02115641", "dingo"], 
-    "274": ["n02115913", "dhole"], 
-    "275": ["n02116738", "African_hunting_dog"], 
-    "276": ["n02117135", "hyena"], 
-    "277": ["n02119022", "red_fox"], 
-    "278": ["n02119789", "kit_fox"], 
-    "279": ["n02120079", "Arctic_fox"], 
-    "280": ["n02120505", "grey_fox"], 
-    "281": ["n02123045", "tabby"], 
-    "282": ["n02123159", "tiger_cat"], 
-    "283": ["n02123394", "Persian_cat"], 
-    "284": ["n02123597", "Siamese_cat"], 
-    "285": ["n02124075", "Egyptian_cat"], 
-    "286": ["n02125311", "cougar"], 
-    "287": ["n02127052", "lynx"], 
-    "288": ["n02128385", "leopard"], 
-    "289": ["n02128757", "snow_leopard"], 
-    "290": ["n02128925", "jaguar"], 
-    "291": ["n02129165", "lion"], 
-    "292": ["n02129604", "tiger"], 
-    "293": ["n02130308", "cheetah"], 
-    "294": ["n02132136", "brown_bear"], 
-    "295": ["n02133161", "American_black_bear"], 
-    "296": ["n02134084", "ice_bear"], 
-    "297": ["n02134418", "sloth_bear"], 
-    "298": ["n02137549", "mongoose"], 
-    "299": ["n02138441", "meerkat"], 
-    "300": ["n02165105", "tiger_beetle"], 
-    "301": ["n02165456", "ladybug"], 
-    "302": ["n02167151", "ground_beetle"], 
-    "303": ["n02168699", "long-horned_beetle"], 
-    "304": ["n02169497", "leaf_beetle"], 
-    "305": ["n02172182", "dung_beetle"], 
-    "306": ["n02174001", "rhinoceros_beetle"], 
-    "307": ["n02177972", "weevil"], 
-    "308": ["n02190166", "fly"], 
-    "309": ["n02206856", "bee"], 
-    "310": ["n02219486", "ant"], 
-    "311": ["n02226429", "grasshopper"], 
-    "312": ["n02229544", "cricket"], 
-    "313": ["n02231487", "walking_stick"], 
-    "314": ["n02233338", "cockroach"], 
-    "315": ["n02236044", "mantis"], 
-    "316": ["n02256656", "cicada"], 
-    "317": ["n02259212", "leafhopper"], 
-    "318": ["n02264363", "lacewing"], 
-    "319": ["n02268443", "dragonfly"], 
-    "320": ["n02268853", "damselfly"], 
-    "321": ["n02276258", "admiral"], 
-    "322": ["n02277742", "ringlet"], 
-    "323": ["n02279972", "monarch"], 
-    "324": ["n02280649", "cabbage_butterfly"], 
-    "325": ["n02281406", "sulphur_butterfly"], 
-    "326": ["n02281787", "lycaenid"], 
-    "327": ["n02317335", "starfish"], 
-    "328": ["n02319095", "sea_urchin"], 
-    "329": ["n02321529", "sea_cucumber"], 
-    "330": ["n02325366", "wood_rabbit"], 
-    "331": ["n02326432", "hare"], 
-    "332": ["n02328150", "Angora"], 
-    "333": ["n02342885", "hamster"], 
-    "334": ["n02346627", "porcupine"], 
-    "335": ["n02356798", "fox_squirrel"], 
-    "336": ["n02361337", "marmot"], 
-    "337": ["n02363005", "beaver"], 
-    "338": ["n02364673", "guinea_pig"], 
-    "339": ["n02389026", "sorrel"], 
-    "340": ["n02391049", "zebra"], 
-    "341": ["n02395406", "hog"], 
-    "342": ["n02396427", "wild_boar"], 
-    "343": ["n02397096", "warthog"], 
-    "344": ["n02398521", "hippopotamus"], 
-    "345": ["n02403003", "ox"], 
-    "346": ["n02408429", "water_buffalo"], 
-    "347": ["n02410509", "bison"], 
-    "348": ["n02412080", "ram"], 
-    "349": ["n02415577", "bighorn"], 
-    "350": ["n02417914", "ibex"], 
-    "351": ["n02422106", "hartebeest"], 
-    "352": ["n02422699", "impala"], 
-    "353": ["n02423022", "gazelle"], 
-    "354": ["n02437312", "Arabian_camel"], 
-    "355": ["n02437616", "llama"], 
-    "356": ["n02441942", "weasel"], 
-    "357": ["n02442845", "mink"], 
-    "358": ["n02443114", "polecat"], 
-    "359": ["n02443484", "black-footed_ferret"], 
-    "360": ["n02444819", "otter"], 
-    "361": ["n02445715", "skunk"], 
-    "362": ["n02447366", "badger"], 
-    "363": ["n02454379", "armadillo"], 
-    "364": ["n02457408", "three-toed_sloth"], 
-    "365": ["n02480495", "orangutan"], 
-    "366": ["n02480855", "gorilla"], 
-    "367": ["n02481823", "chimpanzee"], 
-    "368": ["n02483362", "gibbon"], 
-    "369": ["n02483708", "siamang"], 
-    "370": ["n02484975", "guenon"], 
-    "371": ["n02486261", "patas"], 
-    "372": ["n02486410", "baboon"], 
-    "373": ["n02487347", "macaque"], 
-    "374": ["n02488291", "langur"], 
-    "375": ["n02488702", "colobus"], 
-    "376": ["n02489166", "proboscis_monkey"], 
-    "377": ["n02490219", "marmoset"], 
-    "378": ["n02492035", "capuchin"], 
-    "379": ["n02492660", "howler_monkey"], 
-    "380": ["n02493509", "titi"], 
-    "381": ["n02493793", "spider_monkey"], 
-    "382": ["n02494079", "squirrel_monkey"], 
-    "383": ["n02497673", "Madagascar_cat"], 
-    "384": ["n02500267", "indri"], 
-    "385": ["n02504013", "Indian_elephant"], 
-    "386": ["n02504458", "African_elephant"], 
-    "387": ["n02509815", "lesser_panda"], 
-    "388": ["n02510455", "giant_panda"], 
-    "389": ["n02514041", "barracouta"], 
-    "390": ["n02526121", "eel"], 
-    "391": ["n02536864", "coho"], 
-    "392": ["n02606052", "rock_beauty"], 
-    "393": ["n02607072", "anemone_fish"], 
-    "394": ["n02640242", "sturgeon"], 
-    "395": ["n02641379", "gar"], 
-    "396": ["n02643566", "lionfish"], 
-    "397": ["n02655020", "puffer"], 
-    "398": ["n02666196", "abacus"], 
-    "399": ["n02667093", "abaya"], 
-    "400": ["n02669723", "academic_gown"], 
-    "401": ["n02672831", "accordion"], 
-    "402": ["n02676566", "acoustic_guitar"], 
-    "403": ["n02687172", "aircraft_carrier"], 
-    "404": ["n02690373", "airliner"], 
-    "405": ["n02692877", "airship"], 
-    "406": ["n02699494", "altar"], 
-    "407": ["n02701002", "ambulance"], 
-    "408": ["n02704792", "amphibian"], 
-    "409": ["n02708093", "analog_clock"], 
-    "410": ["n02727426", "apiary"], 
-    "411": ["n02730930", "apron"], 
-    "412": ["n02747177", "ashcan"], 
-    "413": ["n02749479", "assault_rifle"], 
-    "414": ["n02769748", "backpack"], 
-    "415": ["n02776631", "bakery"], 
-    "416": ["n02777292", "balance_beam"], 
-    "417": ["n02782093", "balloon"], 
-    "418": ["n02783161", "ballpoint"], 
-    "419": ["n02786058", "Band_Aid"], 
-    "420": ["n02787622", "banjo"], 
-    "421": ["n02788148", "bannister"], 
-    "422": ["n02790996", "barbell"], 
-    "423": ["n02791124", "barber_chair"], 
-    "424": ["n02791270", "barbershop"], 
-    "425": ["n02793495", "barn"], 
-    "426": ["n02794156", "barometer"], 
-    "427": ["n02795169", "barrel"], 
-    "428": ["n02797295", "barrow"], 
-    "429": ["n02799071", "baseball"], 
-    "430": ["n02802426", "basketball"], 
-    "431": ["n02804414", "bassinet"], 
-    "432": ["n02804610", "bassoon"], 
-    "433": ["n02807133", "bathing_cap"], 
-    "434": ["n02808304", "bath_towel"], 
-    "435": ["n02808440", "bathtub"], 
-    "436": ["n02814533", "beach_wagon"], 
-    "437": ["n02814860", "beacon"], 
-    "438": ["n02815834", "beaker"], 
-    "439": ["n02817516", "bearskin"], 
-    "440": ["n02823428", "beer_bottle"], 
-    "441": ["n02823750", "beer_glass"], 
-    "442": ["n02825657", "bell_cote"], 
-    "443": ["n02834397", "bib"], 
-    "444": ["n02835271", "bicycle-built-for-two"], 
-    "445": ["n02837789", "bikini"], 
-    "446": ["n02840245", "binder"], 
-    "447": ["n02841315", "binoculars"], 
-    "448": ["n02843684", "birdhouse"], 
-    "449": ["n02859443", "boathouse"], 
-    "450": ["n02860847", "bobsled"], 
-    "451": ["n02865351", "bolo_tie"], 
-    "452": ["n02869837", "bonnet"], 
-    "453": ["n02870880", "bookcase"], 
-    "454": ["n02871525", "bookshop"], 
-    "455": ["n02877765", "bottlecap"], 
-    "456": ["n02879718", "bow"], 
-    "457": ["n02883205", "bow_tie"], 
-    "458": ["n02892201", "brass"], 
-    "459": ["n02892767", "brassiere"], 
-    "460": ["n02894605", "breakwater"], 
-    "461": ["n02895154", "breastplate"], 
-    "462": ["n02906734", "broom"], 
-    "463": ["n02909870", "bucket"], 
-    "464": ["n02910353", "buckle"], 
-    "465": ["n02916936", "bulletproof_vest"], 
-    "466": ["n02917067", "bullet_train"], 
-    "467": ["n02927161", "butcher_shop"], 
-    "468": ["n02930766", "cab"], 
-    "469": ["n02939185", "caldron"], 
-    "470": ["n02948072", "candle"], 
-    "471": ["n02950826", "cannon"], 
-    "472": ["n02951358", "canoe"], 
-    "473": ["n02951585", "can_opener"], 
-    "474": ["n02963159", "cardigan"], 
-    "475": ["n02965783", "car_mirror"], 
-    "476": ["n02966193", "carousel"], 
-    "477": ["n02966687", "carpenter's_kit"], 
-    "478": ["n02971356", "carton"], 
-    "479": ["n02974003", "car_wheel"], 
-    "480": ["n02977058", "cash_machine"], 
-    "481": ["n02978881", "cassette"], 
-    "482": ["n02979186", "cassette_player"], 
-    "483": ["n02980441", "castle"], 
-    "484": ["n02981792", "catamaran"], 
-    "485": ["n02988304", "CD_player"], 
-    "486": ["n02992211", "cello"], 
-    "487": ["n02992529", "cellular_telephone"], 
-    "488": ["n02999410", "chain"], 
-    "489": ["n03000134", "chainlink_fence"], 
-    "490": ["n03000247", "chain_mail"], 
-    "491": ["n03000684", "chain_saw"], 
-    "492": ["n03014705", "chest"], 
-    "493": ["n03016953", "chiffonier"], 
-    "494": ["n03017168", "chime"], 
-    "495": ["n03018349", "china_cabinet"], 
-    "496": ["n03026506", "Christmas_stocking"], 
-    "497": ["n03028079", "church"], 
-    "498": ["n03032252", "cinema"], 
-    "499": ["n03041632", "cleaver"], 
-    "500": ["n03042490", "cliff_dwelling"], 
-    "501": ["n03045698", "cloak"], 
-    "502": ["n03047690", "clog"], 
-    "503": ["n03062245", "cocktail_shaker"], 
-    "504": ["n03063599", "coffee_mug"], 
-    "505": ["n03063689", "coffeepot"], 
-    "506": ["n03065424", "coil"], 
-    "507": ["n03075370", "combination_lock"], 
-    "508": ["n03085013", "computer_keyboard"], 
-    "509": ["n03089624", "confectionery"], 
-    "510": ["n03095699", "container_ship"], 
-    "511": ["n03100240", "convertible"], 
-    "512": ["n03109150", "corkscrew"], 
-    "513": ["n03110669", "cornet"], 
-    "514": ["n03124043", "cowboy_boot"], 
-    "515": ["n03124170", "cowboy_hat"], 
-    "516": ["n03125729", "cradle"], 
-    "517": ["n03126707", "crane"], 
-    "518": ["n03127747", "crash_helmet"], 
-    "519": ["n03127925", "crate"], 
-    "520": ["n03131574", "crib"], 
-    "521": ["n03133878", "Crock_Pot"], 
-    "522": ["n03134739", "croquet_ball"], 
-    "523": ["n03141823", "crutch"], 
-    "524": ["n03146219", "cuirass"], 
-    "525": ["n03160309", "dam"], 
-    "526": ["n03179701", "desk"], 
-    "527": ["n03180011", "desktop_computer"], 
-    "528": ["n03187595", "dial_telephone"], 
-    "529": ["n03188531", "diaper"], 
-    "530": ["n03196217", "digital_clock"], 
-    "531": ["n03197337", "digital_watch"], 
-    "532": ["n03201208", "dining_table"], 
-    "533": ["n03207743", "dishrag"], 
-    "534": ["n03207941", "dishwasher"], 
-    "535": ["n03208938", "disk_brake"], 
-    "536": ["n03216828", "dock"], 
-    "537": ["n03218198", "dogsled"], 
-    "538": ["n03220513", "dome"], 
-    "539": ["n03223299", "doormat"], 
-    "540": ["n03240683", "drilling_platform"], 
-    "541": ["n03249569", "drum"], 
-    "542": ["n03250847", "drumstick"], 
-    "543": ["n03255030", "dumbbell"], 
-    "544": ["n03259280", "Dutch_oven"], 
-    "545": ["n03271574", "electric_fan"], 
-    "546": ["n03272010", "electric_guitar"], 
-    "547": ["n03272562", "electric_locomotive"], 
-    "548": ["n03290653", "entertainment_center"], 
-    "549": ["n03291819", "envelope"], 
-    "550": ["n03297495", "espresso_maker"], 
-    "551": ["n03314780", "face_powder"], 
-    "552": ["n03325584", "feather_boa"], 
-    "553": ["n03337140", "file"], 
-    "554": ["n03344393", "fireboat"], 
-    "555": ["n03345487", "fire_engine"], 
-    "556": ["n03347037", "fire_screen"], 
-    "557": ["n03355925", "flagpole"], 
-    "558": ["n03372029", "flute"], 
-    "559": ["n03376595", "folding_chair"], 
-    "560": ["n03379051", "football_helmet"], 
-    "561": ["n03384352", "forklift"], 
-    "562": ["n03388043", "fountain"], 
-    "563": ["n03388183", "fountain_pen"], 
-    "564": ["n03388549", "four-poster"], 
-    "565": ["n03393912", "freight_car"], 
-    "566": ["n03394916", "French_horn"], 
-    "567": ["n03400231", "frying_pan"], 
-    "568": ["n03404251", "fur_coat"], 
-    "569": ["n03417042", "garbage_truck"], 
-    "570": ["n03424325", "gasmask"], 
-    "571": ["n03425413", "gas_pump"], 
-    "572": ["n03443371", "goblet"], 
-    "573": ["n03444034", "go-kart"], 
-    "574": ["n03445777", "golf_ball"], 
-    "575": ["n03445924", "golfcart"], 
-    "576": ["n03447447", "gondola"], 
-    "577": ["n03447721", "gong"], 
-    "578": ["n03450230", "gown"], 
-    "579": ["n03452741", "grand_piano"], 
-    "580": ["n03457902", "greenhouse"], 
-    "581": ["n03459775", "grille"], 
-    "582": ["n03461385", "grocery_store"], 
-    "583": ["n03467068", "guillotine"], 
-    "584": ["n03476684", "hair_slide"], 
-    "585": ["n03476991", "hair_spray"], 
-    "586": ["n03478589", "half_track"], 
-    "587": ["n03481172", "hammer"], 
-    "588": ["n03482405", "hamper"], 
-    "589": ["n03483316", "hand_blower"], 
-    "590": ["n03485407", "hand-held_computer"], 
-    "591": ["n03485794", "handkerchief"], 
-    "592": ["n03492542", "hard_disc"], 
-    "593": ["n03494278", "harmonica"], 
-    "594": ["n03495258", "harp"], 
-    "595": ["n03496892", "harvester"], 
-    "596": ["n03498962", "hatchet"], 
-    "597": ["n03527444", "holster"], 
-    "598": ["n03529860", "home_theater"], 
-    "599": ["n03530642", "honeycomb"], 
-    "600": ["n03532672", "hook"], 
-    "601": ["n03534580", "hoopskirt"], 
-    "602": ["n03535780", "horizontal_bar"], 
-    "603": ["n03538406", "horse_cart"], 
-    "604": ["n03544143", "hourglass"], 
-    "605": ["n03584254", "iPod"], 
-    "606": ["n03584829", "iron"], 
-    "607": ["n03590841", "jack-o'-lantern"], 
-    "608": ["n03594734", "jean"], 
-    "609": ["n03594945", "jeep"], 
-    "610": ["n03595614", "jersey"], 
-    "611": ["n03598930", "jigsaw_puzzle"], 
-    "612": ["n03599486", "jinrikisha"], 
-    "613": ["n03602883", "joystick"], 
-    "614": ["n03617480", "kimono"], 
-    "615": ["n03623198", "knee_pad"], 
-    "616": ["n03627232", "knot"], 
-    "617": ["n03630383", "lab_coat"], 
-    "618": ["n03633091", "ladle"], 
-    "619": ["n03637318", "lampshade"], 
-    "620": ["n03642806", "laptop"], 
-    "621": ["n03649909", "lawn_mower"], 
-    "622": ["n03657121", "lens_cap"], 
-    "623": ["n03658185", "letter_opener"], 
-    "624": ["n03661043", "library"], 
-    "625": ["n03662601", "lifeboat"], 
-    "626": ["n03666591", "lighter"], 
-    "627": ["n03670208", "limousine"], 
-    "628": ["n03673027", "liner"], 
-    "629": ["n03676483", "lipstick"], 
-    "630": ["n03680355", "Loafer"], 
-    "631": ["n03690938", "lotion"], 
-    "632": ["n03691459", "loudspeaker"], 
-    "633": ["n03692522", "loupe"], 
-    "634": ["n03697007", "lumbermill"], 
-    "635": ["n03706229", "magnetic_compass"], 
-    "636": ["n03709823", "mailbag"], 
-    "637": ["n03710193", "mailbox"], 
-    "638": ["n03710637", "maillot"], 
-    "639": ["n03710721", "maillot"], 
-    "640": ["n03717622", "manhole_cover"], 
-    "641": ["n03720891", "maraca"], 
-    "642": ["n03721384", "marimba"], 
-    "643": ["n03724870", "mask"], 
-    "644": ["n03729826", "matchstick"], 
-    "645": ["n03733131", "maypole"], 
-    "646": ["n03733281", "maze"], 
-    "647": ["n03733805", "measuring_cup"], 
-    "648": ["n03742115", "medicine_chest"], 
-    "649": ["n03743016", "megalith"], 
-    "650": ["n03759954", "microphone"], 
-    "651": ["n03761084", "microwave"], 
-    "652": ["n03763968", "military_uniform"], 
-    "653": ["n03764736", "milk_can"], 
-    "654": ["n03769881", "minibus"], 
-    "655": ["n03770439", "miniskirt"], 
-    "656": ["n03770679", "minivan"], 
-    "657": ["n03773504", "missile"], 
-    "658": ["n03775071", "mitten"], 
-    "659": ["n03775546", "mixing_bowl"], 
-    "660": ["n03776460", "mobile_home"], 
-    "661": ["n03777568", "Model_T"], 
-    "662": ["n03777754", "modem"], 
-    "663": ["n03781244", "monastery"], 
-    "664": ["n03782006", "monitor"], 
-    "665": ["n03785016", "moped"], 
-    "666": ["n03786901", "mortar"], 
-    "667": ["n03787032", "mortarboard"], 
-    "668": ["n03788195", "mosque"], 
-    "669": ["n03788365", "mosquito_net"], 
-    "670": ["n03791053", "motor_scooter"], 
-    "671": ["n03792782", "mountain_bike"], 
-    "672": ["n03792972", "mountain_tent"], 
-    "673": ["n03793489", "mouse"], 
-    "674": ["n03794056", "mousetrap"], 
-    "675": ["n03796401", "moving_van"], 
-    "676": ["n03803284", "muzzle"], 
-    "677": ["n03804744", "nail"], 
-    "678": ["n03814639", "neck_brace"], 
-    "679": ["n03814906", "necklace"], 
-    "680": ["n03825788", "nipple"], 
-    "681": ["n03832673", "notebook"], 
-    "682": ["n03837869", "obelisk"], 
-    "683": ["n03838899", "oboe"], 
-    "684": ["n03840681", "ocarina"], 
-    "685": ["n03841143", "odometer"], 
-    "686": ["n03843555", "oil_filter"], 
-    "687": ["n03854065", "organ"], 
-    "688": ["n03857828", "oscilloscope"], 
-    "689": ["n03866082", "overskirt"], 
-    "690": ["n03868242", "oxcart"], 
-    "691": ["n03868863", "oxygen_mask"], 
-    "692": ["n03871628", "packet"], 
-    "693": ["n03873416", "paddle"], 
-    "694": ["n03874293", "paddlewheel"], 
-    "695": ["n03874599", "padlock"], 
-    "696": ["n03876231", "paintbrush"], 
-    "697": ["n03877472", "pajama"], 
-    "698": ["n03877845", "palace"], 
-    "699": ["n03884397", "panpipe"], 
-    "700": ["n03887697", "paper_towel"], 
-    "701": ["n03888257", "parachute"], 
-    "702": ["n03888605", "parallel_bars"], 
-    "703": ["n03891251", "park_bench"], 
-    "704": ["n03891332", "parking_meter"], 
-    "705": ["n03895866", "passenger_car"], 
-    "706": ["n03899768", "patio"], 
-    "707": ["n03902125", "pay-phone"], 
-    "708": ["n03903868", "pedestal"], 
-    "709": ["n03908618", "pencil_box"], 
-    "710": ["n03908714", "pencil_sharpener"], 
-    "711": ["n03916031", "perfume"], 
-    "712": ["n03920288", "Petri_dish"], 
-    "713": ["n03924679", "photocopier"], 
-    "714": ["n03929660", "pick"], 
-    "715": ["n03929855", "pickelhaube"], 
-    "716": ["n03930313", "picket_fence"], 
-    "717": ["n03930630", "pickup"], 
-    "718": ["n03933933", "pier"], 
-    "719": ["n03935335", "piggy_bank"], 
-    "720": ["n03937543", "pill_bottle"], 
-    "721": ["n03938244", "pillow"], 
-    "722": ["n03942813", "ping-pong_ball"], 
-    "723": ["n03944341", "pinwheel"], 
-    "724": ["n03947888", "pirate"], 
-    "725": ["n03950228", "pitcher"], 
-    "726": ["n03954731", "plane"], 
-    "727": ["n03956157", "planetarium"], 
-    "728": ["n03958227", "plastic_bag"], 
-    "729": ["n03961711", "plate_rack"], 
-    "730": ["n03967562", "plow"], 
-    "731": ["n03970156", "plunger"], 
-    "732": ["n03976467", "Polaroid_camera"], 
-    "733": ["n03976657", "pole"], 
-    "734": ["n03977966", "police_van"], 
-    "735": ["n03980874", "poncho"], 
-    "736": ["n03982430", "pool_table"], 
-    "737": ["n03983396", "pop_bottle"], 
-    "738": ["n03991062", "pot"], 
-    "739": ["n03992509", "potter's_wheel"], 
-    "740": ["n03995372", "power_drill"], 
-    "741": ["n03998194", "prayer_rug"], 
-    "742": ["n04004767", "printer"], 
-    "743": ["n04005630", "prison"], 
-    "744": ["n04008634", "projectile"], 
-    "745": ["n04009552", "projector"], 
-    "746": ["n04019541", "puck"], 
-    "747": ["n04023962", "punching_bag"], 
-    "748": ["n04026417", "purse"], 
-    "749": ["n04033901", "quill"], 
-    "750": ["n04033995", "quilt"], 
-    "751": ["n04037443", "racer"], 
-    "752": ["n04039381", "racket"], 
-    "753": ["n04040759", "radiator"], 
-    "754": ["n04041544", "radio"], 
-    "755": ["n04044716", "radio_telescope"], 
-    "756": ["n04049303", "rain_barrel"], 
-    "757": ["n04065272", "recreational_vehicle"], 
-    "758": ["n04067472", "reel"], 
-    "759": ["n04069434", "reflex_camera"], 
-    "760": ["n04070727", "refrigerator"], 
-    "761": ["n04074963", "remote_control"], 
-    "762": ["n04081281", "restaurant"], 
-    "763": ["n04086273", "revolver"], 
-    "764": ["n04090263", "rifle"], 
-    "765": ["n04099969", "rocking_chair"], 
-    "766": ["n04111531", "rotisserie"], 
-    "767": ["n04116512", "rubber_eraser"], 
-    "768": ["n04118538", "rugby_ball"], 
-    "769": ["n04118776", "rule"], 
-    "770": ["n04120489", "running_shoe"], 
-    "771": ["n04125021", "safe"], 
-    "772": ["n04127249", "safety_pin"], 
-    "773": ["n04131690", "saltshaker"], 
-    "774": ["n04133789", "sandal"], 
-    "775": ["n04136333", "sarong"], 
-    "776": ["n04141076", "sax"], 
-    "777": ["n04141327", "scabbard"], 
-    "778": ["n04141975", "scale"], 
-    "779": ["n04146614", "school_bus"], 
-    "780": ["n04147183", "schooner"], 
-    "781": ["n04149813", "scoreboard"], 
-    "782": ["n04152593", "screen"], 
-    "783": ["n04153751", "screw"], 
-    "784": ["n04154565", "screwdriver"], 
-    "785": ["n04162706", "seat_belt"], 
-    "786": ["n04179913", "sewing_machine"], 
-    "787": ["n04192698", "shield"], 
-    "788": ["n04200800", "shoe_shop"], 
-    "789": ["n04201297", "shoji"], 
-    "790": ["n04204238", "shopping_basket"], 
-    "791": ["n04204347", "shopping_cart"], 
-    "792": ["n04208210", "shovel"], 
-    "793": ["n04209133", "shower_cap"], 
-    "794": ["n04209239", "shower_curtain"], 
-    "795": ["n04228054", "ski"], 
-    "796": ["n04229816", "ski_mask"], 
-    "797": ["n04235860", "sleeping_bag"], 
-    "798": ["n04238763", "slide_rule"], 
-    "799": ["n04239074", "sliding_door"], 
-    "800": ["n04243546", "slot"], 
-    "801": ["n04251144", "snorkel"], 
-    "802": ["n04252077", "snowmobile"], 
-    "803": ["n04252225", "snowplow"], 
-    "804": ["n04254120", "soap_dispenser"], 
-    "805": ["n04254680", "soccer_ball"], 
-    "806": ["n04254777", "sock"], 
-    "807": ["n04258138", "solar_dish"], 
-    "808": ["n04259630", "sombrero"], 
-    "809": ["n04263257", "soup_bowl"], 
-    "810": ["n04264628", "space_bar"], 
-    "811": ["n04265275", "space_heater"], 
-    "812": ["n04266014", "space_shuttle"], 
-    "813": ["n04270147", "spatula"], 
-    "814": ["n04273569", "speedboat"], 
-    "815": ["n04275548", "spider_web"], 
-    "816": ["n04277352", "spindle"], 
-    "817": ["n04285008", "sports_car"], 
-    "818": ["n04286575", "spotlight"], 
-    "819": ["n04296562", "stage"], 
-    "820": ["n04310018", "steam_locomotive"], 
-    "821": ["n04311004", "steel_arch_bridge"], 
-    "822": ["n04311174", "steel_drum"], 
-    "823": ["n04317175", "stethoscope"], 
-    "824": ["n04325704", "stole"], 
-    "825": ["n04326547", "stone_wall"], 
-    "826": ["n04328186", "stopwatch"], 
-    "827": ["n04330267", "stove"], 
-    "828": ["n04332243", "strainer"], 
-    "829": ["n04335435", "streetcar"], 
-    "830": ["n04336792", "stretcher"], 
-    "831": ["n04344873", "studio_couch"], 
-    "832": ["n04346328", "stupa"], 
-    "833": ["n04347754", "submarine"], 
-    "834": ["n04350905", "suit"], 
-    "835": ["n04355338", "sundial"], 
-    "836": ["n04355933", "sunglass"], 
-    "837": ["n04356056", "sunglasses"], 
-    "838": ["n04357314", "sunscreen"], 
-    "839": ["n04366367", "suspension_bridge"], 
-    "840": ["n04367480", "swab"], 
-    "841": ["n04370456", "sweatshirt"], 
-    "842": ["n04371430", "swimming_trunks"], 
-    "843": ["n04371774", "swing"], 
-    "844": ["n04372370", "switch"], 
-    "845": ["n04376876", "syringe"], 
-    "846": ["n04380533", "table_lamp"], 
-    "847": ["n04389033", "tank"], 
-    "848": ["n04392985", "tape_player"], 
-    "849": ["n04398044", "teapot"], 
-    "850": ["n04399382", "teddy"], 
-    "851": ["n04404412", "television"], 
-    "852": ["n04409515", "tennis_ball"], 
-    "853": ["n04417672", "thatch"], 
-    "854": ["n04418357", "theater_curtain"], 
-    "855": ["n04423845", "thimble"], 
-    "856": ["n04428191", "thresher"], 
-    "857": ["n04429376", "throne"], 
-    "858": ["n04435653", "tile_roof"], 
-    "859": ["n04442312", "toaster"], 
-    "860": ["n04443257", "tobacco_shop"], 
-    "861": ["n04447861", "toilet_seat"], 
-    "862": ["n04456115", "torch"], 
-    "863": ["n04458633", "totem_pole"], 
-    "864": ["n04461696", "tow_truck"], 
-    "865": ["n04462240", "toyshop"], 
-    "866": ["n04465501", "tractor"], 
-    "867": ["n04467665", "trailer_truck"], 
-    "868": ["n04476259", "tray"], 
-    "869": ["n04479046", "trench_coat"], 
-    "870": ["n04482393", "tricycle"], 
-    "871": ["n04483307", "trimaran"], 
-    "872": ["n04485082", "tripod"], 
-    "873": ["n04486054", "triumphal_arch"], 
-    "874": ["n04487081", "trolleybus"], 
-    "875": ["n04487394", "trombone"], 
-    "876": ["n04493381", "tub"], 
-    "877": ["n04501370", "turnstile"], 
-    "878": ["n04505470", "typewriter_keyboard"], 
-    "879": ["n04507155", "umbrella"], 
-    "880": ["n04509417", "unicycle"], 
-    "881": ["n04515003", "upright"], 
-    "882": ["n04517823", "vacuum"], 
-    "883": ["n04522168", "vase"], 
-    "884": ["n04523525", "vault"], 
-    "885": ["n04525038", "velvet"], 
-    "886": ["n04525305", "vending_machine"], 
-    "887": ["n04532106", "vestment"], 
-    "888": ["n04532670", "viaduct"], 
-    "889": ["n04536866", "violin"], 
-    "890": ["n04540053", "volleyball"], 
-    "891": ["n04542943", "waffle_iron"], 
-    "892": ["n04548280", "wall_clock"], 
-    "893": ["n04548362", "wallet"], 
-    "894": ["n04550184", "wardrobe"], 
-    "895": ["n04552348", "warplane"], 
-    "896": ["n04553703", "washbasin"], 
-    "897": ["n04554684", "washer"], 
-    "898": ["n04557648", "water_bottle"], 
-    "899": ["n04560804", "water_jug"], 
-    "900": ["n04562935", "water_tower"], 
-    "901": ["n04579145", "whiskey_jug"], 
-    "902": ["n04579432", "whistle"], 
-    "903": ["n04584207", "wig"], 
-    "904": ["n04589890", "window_screen"], 
-    "905": ["n04590129", "window_shade"], 
-    "906": ["n04591157", "Windsor_tie"], 
-    "907": ["n04591713", "wine_bottle"], 
-    "908": ["n04592741", "wing"], 
-    "909": ["n04596742", "wok"], 
-    "910": ["n04597913", "wooden_spoon"], 
-    "911": ["n04599235", "wool"], 
-    "912": ["n04604644", "worm_fence"], 
-    "913": ["n04606251", "wreck"], 
-    "914": ["n04612504", "yawl"], 
-    "915": ["n04613696", "yurt"], 
-    "916": ["n06359193", "web_site"], 
-    "917": ["n06596364", "comic_book"], 
-    "918": ["n06785654", "crossword_puzzle"], 
-    "919": ["n06794110", "street_sign"], 
-    "920": ["n06874185", "traffic_light"], 
-    "921": ["n07248320", "book_jacket"], 
-    "922": ["n07565083", "menu"], 
-    "923": ["n07579787", "plate"], 
-    "924": ["n07583066", "guacamole"], 
-    "925": ["n07584110", "consomme"], 
-    "926": ["n07590611", "hot_pot"], 
-    "927": ["n07613480", "trifle"], 
-    "928": ["n07614500", "ice_cream"], 
-    "929": ["n07615774", "ice_lolly"], 
-    "930": ["n07684084", "French_loaf"], 
-    "931": ["n07693725", "bagel"], 
-    "932": ["n07695742", "pretzel"], 
-    "933": ["n07697313", "cheeseburger"], 
-    "934": ["n07697537", "hotdog"], 
-    "935": ["n07711569", "mashed_potato"], 
-    "936": ["n07714571", "head_cabbage"], 
-    "937": ["n07714990", "broccoli"], 
-    "938": ["n07715103", "cauliflower"], 
-    "939": ["n07716358", "zucchini"], 
-    "940": ["n07716906", "spaghetti_squash"], 
-    "941": ["n07717410", "acorn_squash"], 
-    "942": ["n07717556", "butternut_squash"], 
-    "943": ["n07718472", "cucumber"], 
-    "944": ["n07718747", "artichoke"], 
-    "945": ["n07720875", "bell_pepper"], 
-    "946": ["n07730033", "cardoon"], 
-    "947": ["n07734744", "mushroom"], 
-    "948": ["n07742313", "Granny_Smith"], 
-    "949": ["n07745940", "strawberry"], 
-    "950": ["n07747607", "orange"], 
-    "951": ["n07749582", "lemon"], 
-    "952": ["n07753113", "fig"], 
-    "953": ["n07753275", "pineapple"], 
-    "954": ["n07753592", "banana"], 
-    "955": ["n07754684", "jackfruit"], 
-    "956": ["n07760859", "custard_apple"], 
-    "957": ["n07768694", "pomegranate"], 
-    "958": ["n07802026", "hay"], 
-    "959": ["n07831146", "carbonara"], 
-    "960": ["n07836838", "chocolate_sauce"], 
-    "961": ["n07860988", "dough"], 
-    "962": ["n07871810", "meat_loaf"], 
-    "963": ["n07873807", "pizza"], 
-    "964": ["n07875152", "potpie"], 
-    "965": ["n07880968", "burrito"], 
-    "966": ["n07892512", "red_wine"], 
-    "967": ["n07920052", "espresso"], 
-    "968": ["n07930864", "cup"], 
-    "969": ["n07932039", "eggnog"], 
-    "970": ["n09193705", "alp"], 
-    "971": ["n09229709", "bubble"], 
-    "972": ["n09246464", "cliff"], 
-    "973": ["n09256479", "coral_reef"], 
-    "974": ["n09288635", "geyser"], 
-    "975": ["n09332890", "lakeside"], 
-    "976": ["n09399592", "promontory"], 
-    "977": ["n09421951", "sandbar"], 
-    "978": ["n09428293", "seashore"], 
-    "979": ["n09468604", "valley"], 
-    "980": ["n09472597", "volcano"], 
-    "981": ["n09835506", "ballplayer"], 
-    "982": ["n10148035", "groom"], 
-    "983": ["n10565667", "scuba_diver"], 
-    "984": ["n11879895", "rapeseed"], 
-    "985": ["n11939491", "daisy"], 
-    "986": ["n12057211", "yellow_lady's_slipper"], 
-    "987": ["n12144580", "corn"], 
-    "988": ["n12267677", "acorn"], 
-    "989": ["n12620546", "hip"], 
-    "990": ["n12768682", "buckeye"], 
-    "991": ["n12985857", "coral_fungus"], 
-    "992": ["n12998815", "agaric"], 
-    "993": ["n13037406", "gyromitra"], 
-    "994": ["n13040303", "stinkhorn"], 
-    "995": ["n13044778", "earthstar"], 
-    "996": ["n13052670", "hen-of-the-woods"], 
-    "997": ["n13054560", "bolete"], 
-    "998": ["n13133613", "ear"], 
-    "999": ["n15075141", "toilet_tissue"]
-}
\ No newline at end of file
diff --git a/spaces/AnimalEquality/chatbot/_proc/_docs/site_libs/quarto-search/fuse.min.js b/spaces/AnimalEquality/chatbot/_proc/_docs/site_libs/quarto-search/fuse.min.js
deleted file mode 100644
index adc28356e2f591038d4e691cb5b418d7a490bfb1..0000000000000000000000000000000000000000
--- a/spaces/AnimalEquality/chatbot/_proc/_docs/site_libs/quarto-search/fuse.min.js
+++ /dev/null
@@ -1,9 +0,0 @@
-/**
- * Fuse.js v6.6.2 - Lightweight fuzzy-search (http://fusejs.io)
- *
- * Copyright (c) 2022 Kiro Risk (http://kiro.me)
- * All Rights Reserved. Apache Software License 2.0
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- */
-var e,t;e=this,t=function(){"use strict";function e(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function t(t){for(var n=1;n<arguments.length;n++){var r=null!=arguments[n]?arguments[n]:{};n%2?e(Object(r),!0).forEach((function(e){c(t,e,r[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(r)):e(Object(r)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(r,e))}))}return t}function n(e){return n="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},n(e)}function r(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function o(e,t,n){return t&&i(e.prototype,t),n&&i(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function c(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");Object.defineProperty(e,"prototype",{value:Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),writable:!1}),t&&u(e,t)}function s(e){return s=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)},s(e)}function u(e,t){return u=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e},u(e,t)}function h(e,t){if(t&&("object"==typeof t||"function"==typeof t))return t;if(void 0!==t)throw new TypeError("Derived constructors may only return object or undefined");return function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e)}function l(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=s(e);if(t){var i=s(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return h(this,n)}}function f(e){return function(e){if(Array.isArray(e))return d(e)}(e)||function(e){if("undefined"!=typeof Symbol&&null!=e[Symbol.iterator]||null!=e["@@iterator"])return Array.from(e)}(e)||function(e,t){if(e){if("string"==typeof e)return d(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);return"Object"===n&&e.constructor&&(n=e.constructor.name),"Map"===n||"Set"===n?Array.from(e):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?d(e,t):void 0}}(e)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function d(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function v(e){return Array.isArray?Array.isArray(e):"[object Array]"===b(e)}function g(e){return"string"==typeof e}function y(e){return"number"==typeof e}function p(e){return!0===e||!1===e||function(e){return m(e)&&null!==e}(e)&&"[object Boolean]"==b(e)}function m(e){return"object"===n(e)}function k(e){return null!=e}function M(e){return!e.trim().length}function b(e){return null==e?void 0===e?"[object Undefined]":"[object Null]":Object.prototype.toString.call(e)}var x=function(e){return"Invalid value for key ".concat(e)},w=function(e){return"Pattern length exceeds max of ".concat(e,".")},L=Object.prototype.hasOwnProperty,S=function(){function e(t){var n=this;r(this,e),this._keys=[],this._keyMap={};var i=0;t.forEach((function(e){var t=_(e);i+=t.weight,n._keys.push(t),n._keyMap[t.id]=t,i+=t.weight})),this._keys.forEach((function(e){e.weight/=i}))}return o(e,[{key:"get",value:function(e){return this._keyMap[e]}},{key:"keys",value:function(){return this._keys}},{key:"toJSON",value:function(){return JSON.stringify(this._keys)}}]),e}();function _(e){var t=null,n=null,r=null,i=1,o=null;if(g(e)||v(e))r=e,t=O(e),n=j(e);else{if(!L.call(e,"name"))throw new Error(function(e){return"Missing ".concat(e," property in key")}("name"));var c=e.name;if(r=c,L.call(e,"weight")&&(i=e.weight)<=0)throw new Error(function(e){return"Property 'weight' in key '".concat(e,"' must be a positive integer")}(c));t=O(c),n=j(c),o=e.getFn}return{path:t,id:n,weight:i,src:r,getFn:o}}function O(e){return v(e)?e:e.split(".")}function j(e){return v(e)?e.join("."):e}var A={useExtendedSearch:!1,getFn:function(e,t){var n=[],r=!1;return function e(t,i,o){if(k(t))if(i[o]){var c=t[i[o]];if(!k(c))return;if(o===i.length-1&&(g(c)||y(c)||p(c)))n.push(function(e){return null==e?"":function(e){if("string"==typeof e)return e;var t=e+"";return"0"==t&&1/e==-1/0?"-0":t}(e)}(c));else if(v(c)){r=!0;for(var a=0,s=c.length;a<s;a+=1)e(c[a],i,o+1)}else i.length&&e(c,i,o+1)}else n.push(t)}(e,g(t)?t.split("."):t,0),r?n:n[0]},ignoreLocation:!1,ignoreFieldNorm:!1,fieldNormWeight:1},I=t(t(t(t({},{isCaseSensitive:!1,includeScore:!1,keys:[],shouldSort:!0,sortFn:function(e,t){return e.score===t.score?e.idx<t.idx?-1:1:e.score<t.score?-1:1}}),{includeMatches:!1,findAllMatches:!1,minMatchCharLength:1}),{location:0,threshold:.6,distance:100}),A),C=/[^ ]+/g;function E(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:1,t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:3,n=new Map,r=Math.pow(10,t);return{get:function(t){var i=t.match(C).length;if(n.has(i))return n.get(i);var o=1/Math.pow(i,.5*e),c=parseFloat(Math.round(o*r)/r);return n.set(i,c),c},clear:function(){n.clear()}}}var $=function(){function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=t.getFn,i=void 0===n?I.getFn:n,o=t.fieldNormWeight,c=void 0===o?I.fieldNormWeight:o;r(this,e),this.norm=E(c,3),this.getFn=i,this.isCreated=!1,this.setIndexRecords()}return o(e,[{key:"setSources",value:function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];this.docs=e}},{key:"setIndexRecords",value:function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];this.records=e}},{key:"setKeys",value:function(){var e=this,t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];this.keys=t,this._keysMap={},t.forEach((function(t,n){e._keysMap[t.id]=n}))}},{key:"create",value:function(){var e=this;!this.isCreated&&this.docs.length&&(this.isCreated=!0,g(this.docs[0])?this.docs.forEach((function(t,n){e._addString(t,n)})):this.docs.forEach((function(t,n){e._addObject(t,n)})),this.norm.clear())}},{key:"add",value:function(e){var t=this.size();g(e)?this._addString(e,t):this._addObject(e,t)}},{key:"removeAt",value:function(e){this.records.splice(e,1);for(var t=e,n=this.size();t<n;t+=1)this.records[t].i-=1}},{key:"getValueForItemAtKeyId",value:function(e,t){return e[this._keysMap[t]]}},{key:"size",value:function(){return this.records.length}},{key:"_addString",value:function(e,t){if(k(e)&&!M(e)){var n={v:e,i:t,n:this.norm.get(e)};this.records.push(n)}}},{key:"_addObject",value:function(e,t){var n=this,r={i:t,$:{}};this.keys.forEach((function(t,i){var o=t.getFn?t.getFn(e):n.getFn(e,t.path);if(k(o))if(v(o))!function(){for(var e=[],t=[{nestedArrIndex:-1,value:o}];t.length;){var c=t.pop(),a=c.nestedArrIndex,s=c.value;if(k(s))if(g(s)&&!M(s)){var u={v:s,i:a,n:n.norm.get(s)};e.push(u)}else v(s)&&s.forEach((function(e,n){t.push({nestedArrIndex:n,value:e})}))}r.$[i]=e}();else if(g(o)&&!M(o)){var c={v:o,n:n.norm.get(o)};r.$[i]=c}})),this.records.push(r)}},{key:"toJSON",value:function(){return{keys:this.keys,records:this.records}}}]),e}();function F(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},r=n.getFn,i=void 0===r?I.getFn:r,o=n.fieldNormWeight,c=void 0===o?I.fieldNormWeight:o,a=new $({getFn:i,fieldNormWeight:c});return a.setKeys(e.map(_)),a.setSources(t),a.create(),a}function R(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=t.errors,r=void 0===n?0:n,i=t.currentLocation,o=void 0===i?0:i,c=t.expectedLocation,a=void 0===c?0:c,s=t.distance,u=void 0===s?I.distance:s,h=t.ignoreLocation,l=void 0===h?I.ignoreLocation:h,f=r/e.length;if(l)return f;var d=Math.abs(a-o);return u?f+d/u:d?1:f}function N(){for(var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:I.minMatchCharLength,n=[],r=-1,i=-1,o=0,c=e.length;o<c;o+=1){var a=e[o];a&&-1===r?r=o:a||-1===r||((i=o-1)-r+1>=t&&n.push([r,i]),r=-1)}return e[o-1]&&o-r>=t&&n.push([r,o-1]),n}var P=32;function W(e){for(var t={},n=0,r=e.length;n<r;n+=1){var i=e.charAt(n);t[i]=(t[i]||0)|1<<r-n-1}return t}var T=function(){function e(t){var n=this,i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},o=i.location,c=void 0===o?I.location:o,a=i.threshold,s=void 0===a?I.threshold:a,u=i.distance,h=void 0===u?I.distance:u,l=i.includeMatches,f=void 0===l?I.includeMatches:l,d=i.findAllMatches,v=void 0===d?I.findAllMatches:d,g=i.minMatchCharLength,y=void 0===g?I.minMatchCharLength:g,p=i.isCaseSensitive,m=void 0===p?I.isCaseSensitive:p,k=i.ignoreLocation,M=void 0===k?I.ignoreLocation:k;if(r(this,e),this.options={location:c,threshold:s,distance:h,includeMatches:f,findAllMatches:v,minMatchCharLength:y,isCaseSensitive:m,ignoreLocation:M},this.pattern=m?t:t.toLowerCase(),this.chunks=[],this.pattern.length){var b=function(e,t){n.chunks.push({pattern:e,alphabet:W(e),startIndex:t})},x=this.pattern.length;if(x>P){for(var w=0,L=x%P,S=x-L;w<S;)b(this.pattern.substr(w,P),w),w+=P;if(L){var _=x-P;b(this.pattern.substr(_),_)}}else b(this.pattern,0)}}return o(e,[{key:"searchIn",value:function(e){var t=this.options,n=t.isCaseSensitive,r=t.includeMatches;if(n||(e=e.toLowerCase()),this.pattern===e){var i={isMatch:!0,score:0};return r&&(i.indices=[[0,e.length-1]]),i}var o=this.options,c=o.location,a=o.distance,s=o.threshold,u=o.findAllMatches,h=o.minMatchCharLength,l=o.ignoreLocation,d=[],v=0,g=!1;this.chunks.forEach((function(t){var n=t.pattern,i=t.alphabet,o=t.startIndex,y=function(e,t,n){var r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{},i=r.location,o=void 0===i?I.location:i,c=r.distance,a=void 0===c?I.distance:c,s=r.threshold,u=void 0===s?I.threshold:s,h=r.findAllMatches,l=void 0===h?I.findAllMatches:h,f=r.minMatchCharLength,d=void 0===f?I.minMatchCharLength:f,v=r.includeMatches,g=void 0===v?I.includeMatches:v,y=r.ignoreLocation,p=void 0===y?I.ignoreLocation:y;if(t.length>P)throw new Error(w(P));for(var m,k=t.length,M=e.length,b=Math.max(0,Math.min(o,M)),x=u,L=b,S=d>1||g,_=S?Array(M):[];(m=e.indexOf(t,L))>-1;){var O=R(t,{currentLocation:m,expectedLocation:b,distance:a,ignoreLocation:p});if(x=Math.min(O,x),L=m+k,S)for(var j=0;j<k;)_[m+j]=1,j+=1}L=-1;for(var A=[],C=1,E=k+M,$=1<<k-1,F=0;F<k;F+=1){for(var W=0,T=E;W<T;)R(t,{errors:F,currentLocation:b+T,expectedLocation:b,distance:a,ignoreLocation:p})<=x?W=T:E=T,T=Math.floor((E-W)/2+W);E=T;var z=Math.max(1,b-T+1),D=l?M:Math.min(b+T,M)+k,K=Array(D+2);K[D+1]=(1<<F)-1;for(var q=D;q>=z;q-=1){var B=q-1,J=n[e.charAt(B)];if(S&&(_[B]=+!!J),K[q]=(K[q+1]<<1|1)&J,F&&(K[q]|=(A[q+1]|A[q])<<1|1|A[q+1]),K[q]&$&&(C=R(t,{errors:F,currentLocation:B,expectedLocation:b,distance:a,ignoreLocation:p}))<=x){if(x=C,(L=B)<=b)break;z=Math.max(1,2*b-L)}}if(R(t,{errors:F+1,currentLocation:b,expectedLocation:b,distance:a,ignoreLocation:p})>x)break;A=K}var U={isMatch:L>=0,score:Math.max(.001,C)};if(S){var V=N(_,d);V.length?g&&(U.indices=V):U.isMatch=!1}return U}(e,n,i,{location:c+o,distance:a,threshold:s,findAllMatches:u,minMatchCharLength:h,includeMatches:r,ignoreLocation:l}),p=y.isMatch,m=y.score,k=y.indices;p&&(g=!0),v+=m,p&&k&&(d=[].concat(f(d),f(k)))}));var y={isMatch:g,score:g?v/this.chunks.length:1};return g&&r&&(y.indices=d),y}}]),e}(),z=function(){function e(t){r(this,e),this.pattern=t}return o(e,[{key:"search",value:function(){}}],[{key:"isMultiMatch",value:function(e){return D(e,this.multiRegex)}},{key:"isSingleMatch",value:function(e){return D(e,this.singleRegex)}}]),e}();function D(e,t){var n=e.match(t);return n?n[1]:null}var K=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=e===this.pattern;return{isMatch:t,score:t?0:1,indices:[0,this.pattern.length-1]}}}],[{key:"type",get:function(){return"exact"}},{key:"multiRegex",get:function(){return/^="(.*)"$/}},{key:"singleRegex",get:function(){return/^=(.*)$/}}]),n}(z),q=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=-1===e.indexOf(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}}],[{key:"type",get:function(){return"inverse-exact"}},{key:"multiRegex",get:function(){return/^!"(.*)"$/}},{key:"singleRegex",get:function(){return/^!(.*)$/}}]),n}(z),B=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=e.startsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,this.pattern.length-1]}}}],[{key:"type",get:function(){return"prefix-exact"}},{key:"multiRegex",get:function(){return/^\^"(.*)"$/}},{key:"singleRegex",get:function(){return/^\^(.*)$/}}]),n}(z),J=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=!e.startsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}}],[{key:"type",get:function(){return"inverse-prefix-exact"}},{key:"multiRegex",get:function(){return/^!\^"(.*)"$/}},{key:"singleRegex",get:function(){return/^!\^(.*)$/}}]),n}(z),U=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=e.endsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[e.length-this.pattern.length,e.length-1]}}}],[{key:"type",get:function(){return"suffix-exact"}},{key:"multiRegex",get:function(){return/^"(.*)"\$$/}},{key:"singleRegex",get:function(){return/^(.*)\$$/}}]),n}(z),V=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=!e.endsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}}],[{key:"type",get:function(){return"inverse-suffix-exact"}},{key:"multiRegex",get:function(){return/^!"(.*)"\$$/}},{key:"singleRegex",get:function(){return/^!(.*)\$$/}}]),n}(z),G=function(e){a(n,e);var t=l(n);function n(e){var i,o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},c=o.location,a=void 0===c?I.location:c,s=o.threshold,u=void 0===s?I.threshold:s,h=o.distance,l=void 0===h?I.distance:h,f=o.includeMatches,d=void 0===f?I.includeMatches:f,v=o.findAllMatches,g=void 0===v?I.findAllMatches:v,y=o.minMatchCharLength,p=void 0===y?I.minMatchCharLength:y,m=o.isCaseSensitive,k=void 0===m?I.isCaseSensitive:m,M=o.ignoreLocation,b=void 0===M?I.ignoreLocation:M;return r(this,n),(i=t.call(this,e))._bitapSearch=new T(e,{location:a,threshold:u,distance:l,includeMatches:d,findAllMatches:g,minMatchCharLength:p,isCaseSensitive:k,ignoreLocation:b}),i}return o(n,[{key:"search",value:function(e){return this._bitapSearch.searchIn(e)}}],[{key:"type",get:function(){return"fuzzy"}},{key:"multiRegex",get:function(){return/^"(.*)"$/}},{key:"singleRegex",get:function(){return/^(.*)$/}}]),n}(z),H=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){for(var t,n=0,r=[],i=this.pattern.length;(t=e.indexOf(this.pattern,n))>-1;)n=t+i,r.push([t,n-1]);var o=!!r.length;return{isMatch:o,score:o?0:1,indices:r}}}],[{key:"type",get:function(){return"include"}},{key:"multiRegex",get:function(){return/^'"(.*)"$/}},{key:"singleRegex",get:function(){return/^'(.*)$/}}]),n}(z),Q=[K,H,B,J,V,U,q,G],X=Q.length,Y=/ +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;function Z(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return e.split("|").map((function(e){for(var n=e.trim().split(Y).filter((function(e){return e&&!!e.trim()})),r=[],i=0,o=n.length;i<o;i+=1){for(var c=n[i],a=!1,s=-1;!a&&++s<X;){var u=Q[s],h=u.isMultiMatch(c);h&&(r.push(new u(h,t)),a=!0)}if(!a)for(s=-1;++s<X;){var l=Q[s],f=l.isSingleMatch(c);if(f){r.push(new l(f,t));break}}}return r}))}var ee=new Set([G.type,H.type]),te=function(){function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},i=n.isCaseSensitive,o=void 0===i?I.isCaseSensitive:i,c=n.includeMatches,a=void 0===c?I.includeMatches:c,s=n.minMatchCharLength,u=void 0===s?I.minMatchCharLength:s,h=n.ignoreLocation,l=void 0===h?I.ignoreLocation:h,f=n.findAllMatches,d=void 0===f?I.findAllMatches:f,v=n.location,g=void 0===v?I.location:v,y=n.threshold,p=void 0===y?I.threshold:y,m=n.distance,k=void 0===m?I.distance:m;r(this,e),this.query=null,this.options={isCaseSensitive:o,includeMatches:a,minMatchCharLength:u,findAllMatches:d,ignoreLocation:l,location:g,threshold:p,distance:k},this.pattern=o?t:t.toLowerCase(),this.query=Z(this.pattern,this.options)}return o(e,[{key:"searchIn",value:function(e){var t=this.query;if(!t)return{isMatch:!1,score:1};var n=this.options,r=n.includeMatches;e=n.isCaseSensitive?e:e.toLowerCase();for(var i=0,o=[],c=0,a=0,s=t.length;a<s;a+=1){var u=t[a];o.length=0,i=0;for(var h=0,l=u.length;h<l;h+=1){var d=u[h],v=d.search(e),g=v.isMatch,y=v.indices,p=v.score;if(!g){c=0,i=0,o.length=0;break}if(i+=1,c+=p,r){var m=d.constructor.type;ee.has(m)?o=[].concat(f(o),f(y)):o.push(y)}}if(i){var k={isMatch:!0,score:c/i};return r&&(k.indices=o),k}}return{isMatch:!1,score:1}}}],[{key:"condition",value:function(e,t){return t.useExtendedSearch}}]),e}(),ne=[];function re(e,t){for(var n=0,r=ne.length;n<r;n+=1){var i=ne[n];if(i.condition(e,t))return new i(e,t)}return new T(e,t)}var ie="$and",oe="$or",ce="$path",ae="$val",se=function(e){return!(!e[ie]&&!e[oe])},ue=function(e){return!!e[ce]},he=function(e){return!v(e)&&m(e)&&!se(e)},le=function(e){return c({},ie,Object.keys(e).map((function(t){return c({},t,e[t])})))};function fe(e,t){var n=t.ignoreFieldNorm,r=void 0===n?I.ignoreFieldNorm:n;e.forEach((function(e){var t=1;e.matches.forEach((function(e){var n=e.key,i=e.norm,o=e.score,c=n?n.weight:null;t*=Math.pow(0===o&&c?Number.EPSILON:o,(c||1)*(r?1:i))})),e.score=t}))}function de(e,t){var n=e.matches;t.matches=[],k(n)&&n.forEach((function(e){if(k(e.indices)&&e.indices.length){var n={indices:e.indices,value:e.value};e.key&&(n.key=e.key.src),e.idx>-1&&(n.refIndex=e.idx),t.matches.push(n)}}))}function ve(e,t){t.score=e.score}function ge(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},r=n.includeMatches,i=void 0===r?I.includeMatches:r,o=n.includeScore,c=void 0===o?I.includeScore:o,a=[];return i&&a.push(de),c&&a.push(ve),e.map((function(e){var n=e.idx,r={item:t[n],refIndex:n};return a.length&&a.forEach((function(t){t(e,r)})),r}))}var ye=function(){function e(n){var i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},o=arguments.length>2?arguments[2]:void 0;r(this,e),this.options=t(t({},I),i),this.options.useExtendedSearch,this._keyStore=new S(this.options.keys),this.setCollection(n,o)}return o(e,[{key:"setCollection",value:function(e,t){if(this._docs=e,t&&!(t instanceof $))throw new Error("Incorrect 'index' type");this._myIndex=t||F(this.options.keys,this._docs,{getFn:this.options.getFn,fieldNormWeight:this.options.fieldNormWeight})}},{key:"add",value:function(e){k(e)&&(this._docs.push(e),this._myIndex.add(e))}},{key:"remove",value:function(){for(var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:function(){return!1},t=[],n=0,r=this._docs.length;n<r;n+=1){var i=this._docs[n];e(i,n)&&(this.removeAt(n),n-=1,r-=1,t.push(i))}return t}},{key:"removeAt",value:function(e){this._docs.splice(e,1),this._myIndex.removeAt(e)}},{key:"getIndex",value:function(){return this._myIndex}},{key:"search",value:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=t.limit,r=void 0===n?-1:n,i=this.options,o=i.includeMatches,c=i.includeScore,a=i.shouldSort,s=i.sortFn,u=i.ignoreFieldNorm,h=g(e)?g(this._docs[0])?this._searchStringList(e):this._searchObjectList(e):this._searchLogical(e);return fe(h,{ignoreFieldNorm:u}),a&&h.sort(s),y(r)&&r>-1&&(h=h.slice(0,r)),ge(h,this._docs,{includeMatches:o,includeScore:c})}},{key:"_searchStringList",value:function(e){var t=re(e,this.options),n=this._myIndex.records,r=[];return n.forEach((function(e){var n=e.v,i=e.i,o=e.n;if(k(n)){var c=t.searchIn(n),a=c.isMatch,s=c.score,u=c.indices;a&&r.push({item:n,idx:i,matches:[{score:s,value:n,norm:o,indices:u}]})}})),r}},{key:"_searchLogical",value:function(e){var t=this,n=function(e,t){var n=(arguments.length>2&&void 0!==arguments[2]?arguments[2]:{}).auto,r=void 0===n||n,i=function e(n){var i=Object.keys(n),o=ue(n);if(!o&&i.length>1&&!se(n))return e(le(n));if(he(n)){var c=o?n[ce]:i[0],a=o?n[ae]:n[c];if(!g(a))throw new Error(x(c));var s={keyId:j(c),pattern:a};return r&&(s.searcher=re(a,t)),s}var u={children:[],operator:i[0]};return i.forEach((function(t){var r=n[t];v(r)&&r.forEach((function(t){u.children.push(e(t))}))})),u};return se(e)||(e=le(e)),i(e)}(e,this.options),r=function e(n,r,i){if(!n.children){var o=n.keyId,c=n.searcher,a=t._findMatches({key:t._keyStore.get(o),value:t._myIndex.getValueForItemAtKeyId(r,o),searcher:c});return a&&a.length?[{idx:i,item:r,matches:a}]:[]}for(var s=[],u=0,h=n.children.length;u<h;u+=1){var l=e(n.children[u],r,i);if(l.length)s.push.apply(s,f(l));else if(n.operator===ie)return[]}return s},i=this._myIndex.records,o={},c=[];return i.forEach((function(e){var t=e.$,i=e.i;if(k(t)){var a=r(n,t,i);a.length&&(o[i]||(o[i]={idx:i,item:t,matches:[]},c.push(o[i])),a.forEach((function(e){var t,n=e.matches;(t=o[i].matches).push.apply(t,f(n))})))}})),c}},{key:"_searchObjectList",value:function(e){var t=this,n=re(e,this.options),r=this._myIndex,i=r.keys,o=r.records,c=[];return o.forEach((function(e){var r=e.$,o=e.i;if(k(r)){var a=[];i.forEach((function(e,i){a.push.apply(a,f(t._findMatches({key:e,value:r[i],searcher:n})))})),a.length&&c.push({idx:o,item:r,matches:a})}})),c}},{key:"_findMatches",value:function(e){var t=e.key,n=e.value,r=e.searcher;if(!k(n))return[];var i=[];if(v(n))n.forEach((function(e){var n=e.v,o=e.i,c=e.n;if(k(n)){var a=r.searchIn(n),s=a.isMatch,u=a.score,h=a.indices;s&&i.push({score:u,key:t,value:n,idx:o,norm:c,indices:h})}}));else{var o=n.v,c=n.n,a=r.searchIn(o),s=a.isMatch,u=a.score,h=a.indices;s&&i.push({score:u,key:t,value:o,norm:c,indices:h})}return i}}]),e}();return ye.version="6.6.2",ye.createIndex=F,ye.parseIndex=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=t.getFn,r=void 0===n?I.getFn:n,i=t.fieldNormWeight,o=void 0===i?I.fieldNormWeight:i,c=e.keys,a=e.records,s=new $({getFn:r,fieldNormWeight:o});return s.setKeys(c),s.setIndexRecords(a),s},ye.config=I,function(){ne.push.apply(ne,arguments)}(te),ye},"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Fuse=t();
\ No newline at end of file
diff --git a/spaces/Anonymous-123/ImageNet-Editing/object_removal/TFill/model/losses.py b/spaces/Anonymous-123/ImageNet-Editing/object_removal/TFill/model/losses.py
deleted file mode 100644
index b8577df7241e42098fb0ef42c74cd4e13afce384..0000000000000000000000000000000000000000
--- a/spaces/Anonymous-123/ImageNet-Editing/object_removal/TFill/model/losses.py
+++ /dev/null
@@ -1,364 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision.models as models
-
-
-####################################################################################################
-# adversarial loss for different gan mode
-####################################################################################################
-class GANLoss(nn.Module):
-    """Define different GAN objectives.
-
-    The GANLoss class abstracts away the need to create the target label tensor
-    that has the same size as the input.
-    """
-
-    def __init__(self, gan_mode, target_real_label=1.0, target_fake_label=0.0):
-        """ Initialize the GANLoss class.
-
-        Parameters:
-            gan_mode (str) - - the type of GAN objective. It currently supports vanilla, lsgan, and wgangp.
-            target_real_label (bool) - - label for a real image
-            target_fake_label (bool) - - label of a fake image
-
-        Note: Do not use sigmoid as the last layer of Discriminator.
-        LSGAN needs no sigmoid. vanilla GANs will handle it with BCEWithLogitsLoss.
-        """
-        super(GANLoss, self).__init__()
-        self.register_buffer('real_label', torch.tensor(target_real_label))
-        self.register_buffer('fake_label', torch.tensor(target_fake_label))
-        self.gan_mode = gan_mode
-        if gan_mode == 'lsgan':
-            self.loss = nn.MSELoss()
-        elif gan_mode == 'vanilla':
-            self.loss = nn.BCEWithLogitsLoss()
-        elif gan_mode == 'hinge':
-            self.loss = nn.ReLU()
-        elif gan_mode in ['wgangp', 'nonsaturating']:
-            self.loss = None
-        else:
-            raise NotImplementedError('gan mode %s not implemented' % gan_mode)
-
-    def get_target_tensor(self, prediction, target_is_real):
-        """Create label tensors with the same size as the input.
-
-        Parameters:
-            prediction (tensor) - - tpyically the prediction from a discriminator
-            target_is_real (bool) - - if the ground truth label is for real examples or fake examples
-
-        Returns:
-            A label tensor filled with ground truth label, and with the size of the input
-        """
-
-        if target_is_real:
-            target_tensor = self.real_label
-        else:
-            target_tensor = self.fake_label
-        return target_tensor.expand_as(prediction)
-
-    def calculate_loss(self, prediction, target_is_real, is_dis=False):
-        """Calculate loss given Discriminator's output and grount truth labels.
-
-        Parameters:
-            prediction (tensor) - - tpyically the prediction output from a discriminator
-            target_is_real (bool) - - if the ground truth label is for real examples or fake examples
-
-        Returns:
-            the calculated loss.
-        """
-        if self.gan_mode in ['lsgan', 'vanilla']:
-            target_tensor = self.get_target_tensor(prediction, target_is_real)
-            loss = self.loss(prediction, target_tensor)
-            if self.gan_mode == 'lsgan':
-                loss = loss * 0.5
-        else:
-            if is_dis:
-                if target_is_real:
-                    prediction = -prediction
-                if self.gan_mode == 'wgangp':
-                    loss = prediction.mean()
-                elif self.gan_mode == 'nonsaturating':
-                    loss = F.softplus(prediction).mean()
-                elif self.gan_mode == 'hinge':
-                    loss = self.loss(1+prediction).mean()
-            else:
-                if self.gan_mode == 'nonsaturating':
-                   loss = F.softplus(-prediction).mean()
-                else:
-                    loss = -prediction.mean()
-        return loss
-
-    def __call__(self, predictions, target_is_real, is_dis=False):
-        """Calculate loss for multi-scales gan"""
-        if isinstance(predictions, list):
-            losses = []
-            for prediction in predictions:
-                losses.append(self.calculate_loss(prediction, target_is_real, is_dis))
-            loss = sum(losses)
-        else:
-            loss = self.calculate_loss(predictions, target_is_real, is_dis)
-
-        return loss
-
-
-def cal_gradient_penalty(netD, real_data, fake_data, device, type='mixed', constant=1.0, lambda_gp=10.0):
-    """Calculate the gradient penalty loss, used in WGAN-GP paper https://arxiv.org/abs/1704.00028
-
-    Arguments:
-        netD (network)              -- discriminator network
-        real_data (tensor array)    -- real examples
-        fake_data (tensor array)    -- generated examples from the generator
-        device (str)                -- GPU / CPU: from torch.device('cuda:{}'.format(self.gpu_ids[0])) if self.gpu_ids else torch.device('cpu')
-        type (str)                  -- if we mix real and fake data or not [real | fake | mixed].
-        constant (float)            -- the constant used in formula ( ||gradient||_2 - constant)^2
-        lambda_gp (float)           -- weight for this loss
-
-    Returns the gradient penalty loss
-    """
-    if lambda_gp > 0.0:
-        if type == 'real':   # either use real examples, fake examples, or a linear interpolation of two.
-            interpolatesv = real_data
-        elif type == 'fake':
-            interpolatesv = fake_data
-        elif type == 'mixed':
-            alpha = torch.rand(real_data.shape[0], 1, device=device)
-            alpha = alpha.expand(real_data.shape[0], real_data.nelement() // real_data.shape[0]).contiguous().view(*real_data.shape)
-            interpolatesv = alpha * real_data + ((1 - alpha) * fake_data)
-        else:
-            raise NotImplementedError('{} not implemented'.format(type))
-        interpolatesv.requires_grad_(True)
-        disc_interpolates = netD(interpolatesv)
-        if isinstance(disc_interpolates, list):
-            gradients = 0
-            for disc_interpolate in disc_interpolates:
-                gradients += torch.autograd.grad(outputs=disc_interpolate, inputs=interpolatesv,
-                                        grad_outputs=torch.ones(disc_interpolate.size()).to(device),
-                                        create_graph=True, retain_graph=True, only_inputs=True)[0]
-        else:
-            gradients = torch.autograd.grad(outputs=disc_interpolates, inputs=interpolatesv,
-                                            grad_outputs=torch.ones(disc_interpolates.size()).to(device),
-                                            create_graph=True, retain_graph=True, only_inputs=True)[0]
-        gradients = gradients.view(real_data.size(0), -1)  # flat the data
-        gradient_penalty = (((gradients + 1e-16).norm(2, dim=1) - constant) ** 2).mean() * lambda_gp        # added eps
-        return gradient_penalty, gradients
-    else:
-        return 0.0, None
-
-
-####################################################################################################
-# trained LPIPS loss
-####################################################################################################
-def normalize_tensor(x, eps=1e-10):
-    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))
-    return x/(norm_factor+eps)
-
-
-def spatial_average(x, keepdim=True):
-    return x.mean([2, 3], keepdim=keepdim)
-
-
-class NetLinLayer(nn.Module):
-    """ A single linear layer which does a 1x1 conv """
-    def __init__(self, chn_in, chn_out=1, use_dropout=False):
-        super(NetLinLayer, self).__init__()
-        layers = [nn.Dropout(), ] if (use_dropout) else []
-        layers += [nn.Conv2d(chn_in, chn_out, 1, stride=1, padding=0, bias=False), ]
-        self.model = nn.Sequential(*layers)
-
-
-class LPIPSLoss(nn.Module):
-    """
-    Learned perceptual metric
-    https://github.com/richzhang/PerceptualSimilarity
-    """
-    def __init__(self, use_dropout=True, ckpt_path=None):
-        super(LPIPSLoss, self).__init__()
-        self.path = ckpt_path
-        self.net = VGG16()
-        self.chns = [64, 128, 256, 512, 512]  # vg16 features
-        self.lin0 = NetLinLayer(self.chns[0], use_dropout=use_dropout)
-        self.lin1 = NetLinLayer(self.chns[1], use_dropout=use_dropout)
-        self.lin2 = NetLinLayer(self.chns[2], use_dropout=use_dropout)
-        self.lin3 = NetLinLayer(self.chns[3], use_dropout=use_dropout)
-        self.lin4 = NetLinLayer(self.chns[4], use_dropout=use_dropout)
-        self.load_from_pretrained()
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def load_from_pretrained(self):
-        self.load_state_dict(torch.load(self.path, map_location=torch.device("cpu")), strict=False)
-        print("loaded pretrained LPIPS loss from {}".format(self.path))
-
-    def _get_features(self, vgg_f):
-        names = ['relu1_2', 'relu2_2', 'relu3_3', 'relu4_3', 'relu5_3']
-        feats = []
-        for i in range(len(names)):
-            name = names[i]
-            feat = vgg_f[name]
-            feats.append(feat)
-        return feats
-
-    def forward(self, x, y):
-        x_vgg, y_vgg = self._get_features(self.net(x)), self._get_features(self.net(y))
-        lins = [self.lin0, self.lin1, self.lin2, self.lin3, self.lin4]
-        reses = []
-        loss = 0
-
-        for i in range(len(self.chns)):
-            x_feats, y_feats = normalize_tensor(x_vgg[i]), normalize_tensor(y_vgg[i])
-            diffs = (x_feats - y_feats) ** 2
-            res = spatial_average(lins[i].model(diffs))
-            loss += res
-            reses.append(res)
-
-        return loss
-
-
-class PerceptualLoss(nn.Module):
-    r"""
-    Perceptual loss, VGG-based
-    https://arxiv.org/abs/1603.08155
-    https://github.com/dxyang/StyleTransfer/blob/master/utils.py
-    """
-
-    def __init__(self, weights=[1.0, 1.0, 1.0, 1.0, 0.0]):
-        super(PerceptualLoss, self).__init__()
-        self.add_module('vgg', VGG16())
-        self.criterion = nn.L1Loss()
-        self.weights = weights
-
-    def __call__(self, x, y):
-        # Compute features
-        x_vgg, y_vgg = self.vgg(x), self.vgg(y)
-
-        content_loss = 0.0
-        content_loss += self.weights[0] * self.criterion(x_vgg['relu1_2'], y_vgg['relu1_2']) if self.weights[0] > 0 else 0
-        content_loss += self.weights[1] * self.criterion(x_vgg['relu2_2'], y_vgg['relu2_2']) if self.weights[1] > 0 else 0
-        content_loss += self.weights[2] * self.criterion(x_vgg['relu3_3'], y_vgg['relu3_3']) if self.weights[2] > 0 else 0
-        content_loss += self.weights[3] * self.criterion(x_vgg['relu4_3'], y_vgg['relu4_3']) if self.weights[3] > 0 else 0
-        content_loss += self.weights[4] * self.criterion(x_vgg['relu5_3'], y_vgg['relu5_3']) if self.weights[4] > 0 else 0
-
-        return content_loss
-
-
-class Normalization(nn.Module):
-    def __init__(self, device):
-        super(Normalization, self).__init__()
-        # .view the mean and std to make them [C x 1 x 1] so that they can
-        # directly work with image Tensor of shape [B x C x H x W].
-        # B is batch size. C is number of channels. H is height and W is width.
-        mean = torch.tensor([0.485, 0.456, 0.406]).to(device)
-        std = torch.tensor([0.229, 0.224, 0.225]).to(device)
-        self.mean = mean.view(-1, 1, 1)
-        self.std = std.view(-1, 1, 1)
-
-    def forward(self, img):
-        # normalize img
-        return (img - self.mean) / self.std
-
-
-class VGG16(nn.Module):
-    def __init__(self):
-        super(VGG16, self).__init__()
-        features = models.vgg16(pretrained=True).features
-        self.relu1_1 = torch.nn.Sequential()
-        self.relu1_2 = torch.nn.Sequential()
-
-        self.relu2_1 = torch.nn.Sequential()
-        self.relu2_2 = torch.nn.Sequential()
-
-        self.relu3_1 = torch.nn.Sequential()
-        self.relu3_2 = torch.nn.Sequential()
-        self.relu3_3 = torch.nn.Sequential()
-
-        self.relu4_1 = torch.nn.Sequential()
-        self.relu4_2 = torch.nn.Sequential()
-        self.relu4_3 = torch.nn.Sequential()
-
-        self.relu5_1 = torch.nn.Sequential()
-        self.relu5_2 = torch.nn.Sequential()
-        self.relu5_3 = torch.nn.Sequential()
-
-        for x in range(2):
-            self.relu1_1.add_module(str(x), features[x])
-
-        for x in range(2, 4):
-            self.relu1_2.add_module(str(x), features[x])
-
-        for x in range(4, 7):
-            self.relu2_1.add_module(str(x), features[x])
-
-        for x in range(7, 9):
-            self.relu2_2.add_module(str(x), features[x])
-
-        for x in range(9, 12):
-            self.relu3_1.add_module(str(x), features[x])
-
-        for x in range(12, 14):
-            self.relu3_2.add_module(str(x), features[x])
-
-        for x in range(14, 16):
-            self.relu3_3.add_module(str(x), features[x])
-
-        for x in range(16, 18):
-            self.relu4_1.add_module(str(x), features[x])
-
-        for x in range(18, 21):
-            self.relu4_2.add_module(str(x), features[x])
-
-        for x in range(21, 23):
-            self.relu4_3.add_module(str(x), features[x])
-
-        for x in range(23, 26):
-            self.relu5_1.add_module(str(x), features[x])
-
-        for x in range(26, 28):
-            self.relu5_2.add_module(str(x), features[x])
-
-        for x in range(28, 30):
-            self.relu5_3.add_module(str(x), features[x])
-
-        # don't need the gradients, just want the features
-        for param in self.parameters():
-           param.requires_grad = False
-
-    def forward(self, x,):
-        relu1_1 = self.relu1_1(x)
-        relu1_2 = self.relu1_2(relu1_1)
-
-        relu2_1 = self.relu2_1(relu1_2)
-        relu2_2 = self.relu2_2(relu2_1)
-
-        relu3_1 = self.relu3_1(relu2_2)
-        relu3_2 = self.relu3_2(relu3_1)
-        relu3_3 = self.relu3_3(relu3_2)
-
-        relu4_1 = self.relu4_1(relu3_3)
-        relu4_2 = self.relu4_2(relu4_1)
-        relu4_3 = self.relu4_3(relu4_2)
-
-        relu5_1 = self.relu5_1(relu4_3)
-        relu5_2 = self.relu5_2(relu5_1)
-        relu5_3 = self.relu5_3(relu5_2)
-
-        out = {
-            'relu1_1': relu1_1,
-            'relu1_2': relu1_2,
-
-            'relu2_1': relu2_1,
-            'relu2_2': relu2_2,
-
-            'relu3_1': relu3_1,
-            'relu3_2': relu3_2,
-            'relu3_3': relu3_3,
-
-            'relu4_1': relu4_1,
-            'relu4_2': relu4_2,
-            'relu4_3': relu4_3,
-
-            'relu5_1': relu5_1,
-            'relu5_2': relu5_2,
-            'relu5_3': relu5_3,
-        }
-        return out
\ No newline at end of file
diff --git a/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/image/io.py b/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/image/io.py
deleted file mode 100644
index d3fa2e8cc06b1a7b0b69de6406980b15d61a1e5d..0000000000000000000000000000000000000000
--- a/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/image/io.py
+++ /dev/null
@@ -1,258 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import io
-import os.path as osp
-from pathlib import Path
-
-import cv2
-import numpy as np
-from cv2 import (IMREAD_COLOR, IMREAD_GRAYSCALE, IMREAD_IGNORE_ORIENTATION,
-                 IMREAD_UNCHANGED)
-
-from annotator.uniformer.mmcv.utils import check_file_exist, is_str, mkdir_or_exist
-
-try:
-    from turbojpeg import TJCS_RGB, TJPF_BGR, TJPF_GRAY, TurboJPEG
-except ImportError:
-    TJCS_RGB = TJPF_GRAY = TJPF_BGR = TurboJPEG = None
-
-try:
-    from PIL import Image, ImageOps
-except ImportError:
-    Image = None
-
-try:
-    import tifffile
-except ImportError:
-    tifffile = None
-
-jpeg = None
-supported_backends = ['cv2', 'turbojpeg', 'pillow', 'tifffile']
-
-imread_flags = {
-    'color': IMREAD_COLOR,
-    'grayscale': IMREAD_GRAYSCALE,
-    'unchanged': IMREAD_UNCHANGED,
-    'color_ignore_orientation': IMREAD_IGNORE_ORIENTATION | IMREAD_COLOR,
-    'grayscale_ignore_orientation':
-    IMREAD_IGNORE_ORIENTATION | IMREAD_GRAYSCALE
-}
-
-imread_backend = 'cv2'
-
-
-def use_backend(backend):
-    """Select a backend for image decoding.
-
-    Args:
-        backend (str): The image decoding backend type. Options are `cv2`,
-        `pillow`, `turbojpeg` (see https://github.com/lilohuang/PyTurboJPEG)
-        and `tifffile`. `turbojpeg` is faster but it only supports `.jpeg`
-        file format.
-    """
-    assert backend in supported_backends
-    global imread_backend
-    imread_backend = backend
-    if imread_backend == 'turbojpeg':
-        if TurboJPEG is None:
-            raise ImportError('`PyTurboJPEG` is not installed')
-        global jpeg
-        if jpeg is None:
-            jpeg = TurboJPEG()
-    elif imread_backend == 'pillow':
-        if Image is None:
-            raise ImportError('`Pillow` is not installed')
-    elif imread_backend == 'tifffile':
-        if tifffile is None:
-            raise ImportError('`tifffile` is not installed')
-
-
-def _jpegflag(flag='color', channel_order='bgr'):
-    channel_order = channel_order.lower()
-    if channel_order not in ['rgb', 'bgr']:
-        raise ValueError('channel order must be either "rgb" or "bgr"')
-
-    if flag == 'color':
-        if channel_order == 'bgr':
-            return TJPF_BGR
-        elif channel_order == 'rgb':
-            return TJCS_RGB
-    elif flag == 'grayscale':
-        return TJPF_GRAY
-    else:
-        raise ValueError('flag must be "color" or "grayscale"')
-
-
-def _pillow2array(img, flag='color', channel_order='bgr'):
-    """Convert a pillow image to numpy array.
-
-    Args:
-        img (:obj:`PIL.Image.Image`): The image loaded using PIL
-        flag (str): Flags specifying the color type of a loaded image,
-            candidates are 'color', 'grayscale' and 'unchanged'.
-            Default to 'color'.
-        channel_order (str): The channel order of the output image array,
-            candidates are 'bgr' and 'rgb'. Default to 'bgr'.
-
-    Returns:
-        np.ndarray: The converted numpy array
-    """
-    channel_order = channel_order.lower()
-    if channel_order not in ['rgb', 'bgr']:
-        raise ValueError('channel order must be either "rgb" or "bgr"')
-
-    if flag == 'unchanged':
-        array = np.array(img)
-        if array.ndim >= 3 and array.shape[2] >= 3:  # color image
-            array[:, :, :3] = array[:, :, (2, 1, 0)]  # RGB to BGR
-    else:
-        # Handle exif orientation tag
-        if flag in ['color', 'grayscale']:
-            img = ImageOps.exif_transpose(img)
-        # If the image mode is not 'RGB', convert it to 'RGB' first.
-        if img.mode != 'RGB':
-            if img.mode != 'LA':
-                # Most formats except 'LA' can be directly converted to RGB
-                img = img.convert('RGB')
-            else:
-                # When the mode is 'LA', the default conversion will fill in
-                #  the canvas with black, which sometimes shadows black objects
-                #  in the foreground.
-                #
-                # Therefore, a random color (124, 117, 104) is used for canvas
-                img_rgba = img.convert('RGBA')
-                img = Image.new('RGB', img_rgba.size, (124, 117, 104))
-                img.paste(img_rgba, mask=img_rgba.split()[3])  # 3 is alpha
-        if flag in ['color', 'color_ignore_orientation']:
-            array = np.array(img)
-            if channel_order != 'rgb':
-                array = array[:, :, ::-1]  # RGB to BGR
-        elif flag in ['grayscale', 'grayscale_ignore_orientation']:
-            img = img.convert('L')
-            array = np.array(img)
-        else:
-            raise ValueError(
-                'flag must be "color", "grayscale", "unchanged", '
-                f'"color_ignore_orientation" or "grayscale_ignore_orientation"'
-                f' but got {flag}')
-    return array
-
-
-def imread(img_or_path, flag='color', channel_order='bgr', backend=None):
-    """Read an image.
-
-    Args:
-        img_or_path (ndarray or str or Path): Either a numpy array or str or
-            pathlib.Path. If it is a numpy array (loaded image), then
-            it will be returned as is.
-        flag (str): Flags specifying the color type of a loaded image,
-            candidates are `color`, `grayscale`, `unchanged`,
-            `color_ignore_orientation` and `grayscale_ignore_orientation`.
-            By default, `cv2` and `pillow` backend would rotate the image
-            according to its EXIF info unless called with `unchanged` or
-            `*_ignore_orientation` flags. `turbojpeg` and `tifffile` backend
-            always ignore image's EXIF info regardless of the flag.
-            The `turbojpeg` backend only supports `color` and `grayscale`.
-        channel_order (str): Order of channel, candidates are `bgr` and `rgb`.
-        backend (str | None): The image decoding backend type. Options are
-            `cv2`, `pillow`, `turbojpeg`, `tifffile`, `None`.
-            If backend is None, the global imread_backend specified by
-            ``mmcv.use_backend()`` will be used. Default: None.
-
-    Returns:
-        ndarray: Loaded image array.
-    """
-
-    if backend is None:
-        backend = imread_backend
-    if backend not in supported_backends:
-        raise ValueError(f'backend: {backend} is not supported. Supported '
-                         "backends are 'cv2', 'turbojpeg', 'pillow'")
-    if isinstance(img_or_path, Path):
-        img_or_path = str(img_or_path)
-
-    if isinstance(img_or_path, np.ndarray):
-        return img_or_path
-    elif is_str(img_or_path):
-        check_file_exist(img_or_path,
-                         f'img file does not exist: {img_or_path}')
-        if backend == 'turbojpeg':
-            with open(img_or_path, 'rb') as in_file:
-                img = jpeg.decode(in_file.read(),
-                                  _jpegflag(flag, channel_order))
-                if img.shape[-1] == 1:
-                    img = img[:, :, 0]
-            return img
-        elif backend == 'pillow':
-            img = Image.open(img_or_path)
-            img = _pillow2array(img, flag, channel_order)
-            return img
-        elif backend == 'tifffile':
-            img = tifffile.imread(img_or_path)
-            return img
-        else:
-            flag = imread_flags[flag] if is_str(flag) else flag
-            img = cv2.imread(img_or_path, flag)
-            if flag == IMREAD_COLOR and channel_order == 'rgb':
-                cv2.cvtColor(img, cv2.COLOR_BGR2RGB, img)
-            return img
-    else:
-        raise TypeError('"img" must be a numpy array or a str or '
-                        'a pathlib.Path object')
-
-
-def imfrombytes(content, flag='color', channel_order='bgr', backend=None):
-    """Read an image from bytes.
-
-    Args:
-        content (bytes): Image bytes got from files or other streams.
-        flag (str): Same as :func:`imread`.
-        backend (str | None): The image decoding backend type. Options are
-            `cv2`, `pillow`, `turbojpeg`, `None`. If backend is None, the
-            global imread_backend specified by ``mmcv.use_backend()`` will be
-            used. Default: None.
-
-    Returns:
-        ndarray: Loaded image array.
-    """
-
-    if backend is None:
-        backend = imread_backend
-    if backend not in supported_backends:
-        raise ValueError(f'backend: {backend} is not supported. Supported '
-                         "backends are 'cv2', 'turbojpeg', 'pillow'")
-    if backend == 'turbojpeg':
-        img = jpeg.decode(content, _jpegflag(flag, channel_order))
-        if img.shape[-1] == 1:
-            img = img[:, :, 0]
-        return img
-    elif backend == 'pillow':
-        buff = io.BytesIO(content)
-        img = Image.open(buff)
-        img = _pillow2array(img, flag, channel_order)
-        return img
-    else:
-        img_np = np.frombuffer(content, np.uint8)
-        flag = imread_flags[flag] if is_str(flag) else flag
-        img = cv2.imdecode(img_np, flag)
-        if flag == IMREAD_COLOR and channel_order == 'rgb':
-            cv2.cvtColor(img, cv2.COLOR_BGR2RGB, img)
-        return img
-
-
-def imwrite(img, file_path, params=None, auto_mkdir=True):
-    """Write image to file.
-
-    Args:
-        img (ndarray): Image array to be written.
-        file_path (str): Image file path.
-        params (None or list): Same as opencv :func:`imwrite` interface.
-        auto_mkdir (bool): If the parent folder of `file_path` does not exist,
-            whether to create it automatically.
-
-    Returns:
-        bool: Successful or not.
-    """
-    if auto_mkdir:
-        dir_name = osp.abspath(osp.dirname(file_path))
-        mkdir_or_exist(dir_name)
-    return cv2.imwrite(file_path, img, params)
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_distutils/log.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_distutils/log.py
deleted file mode 100644
index be25f6cabd839af772dd74399c57991c222d3da8..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_distutils/log.py
+++ /dev/null
@@ -1,80 +0,0 @@
-"""A simple log mechanism styled after PEP 282."""
-
-# The class here is styled after PEP 282 so that it could later be
-# replaced with a standard Python logging implementation.
-
-import sys
-
-DEBUG = 1
-INFO = 2
-WARN = 3
-ERROR = 4
-FATAL = 5
-
-
-class Log:
-    def __init__(self, threshold=WARN):
-        self.threshold = threshold
-
-    def _log(self, level, msg, args):
-        if level not in (DEBUG, INFO, WARN, ERROR, FATAL):
-            raise ValueError('%s wrong log level' % str(level))
-
-        if level >= self.threshold:
-            if args:
-                msg = msg % args
-            if level in (WARN, ERROR, FATAL):
-                stream = sys.stderr
-            else:
-                stream = sys.stdout
-            try:
-                stream.write('%s\n' % msg)
-            except UnicodeEncodeError:
-                # emulate backslashreplace error handler
-                encoding = stream.encoding
-                msg = msg.encode(encoding, "backslashreplace").decode(encoding)
-                stream.write('%s\n' % msg)
-            stream.flush()
-
-    def log(self, level, msg, *args):
-        self._log(level, msg, args)
-
-    def debug(self, msg, *args):
-        self._log(DEBUG, msg, args)
-
-    def info(self, msg, *args):
-        self._log(INFO, msg, args)
-
-    def warn(self, msg, *args):
-        self._log(WARN, msg, args)
-
-    def error(self, msg, *args):
-        self._log(ERROR, msg, args)
-
-    def fatal(self, msg, *args):
-        self._log(FATAL, msg, args)
-
-
-_global_log = Log()
-log = _global_log.log
-debug = _global_log.debug
-info = _global_log.info
-warn = _global_log.warn
-error = _global_log.error
-fatal = _global_log.fatal
-
-
-def set_threshold(level):
-    # return the old threshold for use from tests
-    old = _global_log.threshold
-    _global_log.threshold = level
-    return old
-
-
-def set_verbosity(v):
-    if v <= 0:
-        set_threshold(WARN)
-    elif v == 1:
-        set_threshold(INFO)
-    elif v >= 2:
-        set_threshold(DEBUG)
diff --git a/spaces/Audio-AGI/WavJourney/VoiceParser/hubert_manager.py b/spaces/Audio-AGI/WavJourney/VoiceParser/hubert_manager.py
deleted file mode 100644
index 5f8445147a8997fdb54e1246e9a85af40342c748..0000000000000000000000000000000000000000
--- a/spaces/Audio-AGI/WavJourney/VoiceParser/hubert_manager.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import os.path
-import shutil
-import urllib.request
-
-import huggingface_hub
-
-
-class HuBERTManager:
-    @staticmethod
-    def make_sure_hubert_installed(download_url: str = 'https://dl.fbaipublicfiles.com/hubert/hubert_base_ls960.pt', file_name: str = 'hubert.pt'):
-        install_dir = os.path.join('VoiceParser', 'hubert')
-        if not os.path.isdir(install_dir):
-            os.makedirs(install_dir, exist_ok=True)
-        install_file = os.path.join(install_dir, file_name)
-        if not os.path.isfile(install_file):
-            print('Downloading HuBERT base model')
-            urllib.request.urlretrieve(download_url, install_file)
-            print('Downloaded HuBERT')
-        return install_file
-
-
-    @staticmethod
-    def make_sure_tokenizer_installed(model: str = 'quantifier_hubert_base_ls960_14.pth', repo: str = 'GitMylo/bark-voice-cloning', local_file: str = 'tokenizer.pth'):
-        install_dir = os.path.join('VoiceParser', 'hubert')
-        if not os.path.isdir(install_dir):
-            os.makedirs(install_dir, exist_ok=True)
-        install_file = os.path.join(install_dir, local_file)
-        if not os.path.isfile(install_file):
-            print('Downloading HuBERT custom tokenizer')
-            huggingface_hub.hf_hub_download(repo, model, local_dir=install_dir, local_dir_use_symlinks=False)
-            shutil.move(os.path.join(install_dir, model), install_file)
-            print('Downloaded tokenizer')
-        return install_file
\ No newline at end of file
diff --git a/spaces/Audio-AGI/WavJourney/voice_presets.py b/spaces/Audio-AGI/WavJourney/voice_presets.py
deleted file mode 100644
index 5cf8ed05c3c45bf550254b206e25345cd21759b9..0000000000000000000000000000000000000000
--- a/spaces/Audio-AGI/WavJourney/voice_presets.py
+++ /dev/null
@@ -1,96 +0,0 @@
-import os
-import json, json5
-from pathlib import Path
-
-import utils
-from APIs import VP
-
-
-def save_voice_presets_metadata(voice_presets_path, metadata):
-    with open(voice_presets_path / 'metadata.json', 'w') as f:
-        json.dump(metadata, f, indent=4)
-
-def load_voice_presets_metadata(voice_presets_path, safe_if_metadata_not_exist=False):
-    metadata_full_path = Path(voice_presets_path) / 'metadata.json'
-
-    if safe_if_metadata_not_exist:
-        if not os.path.exists(metadata_full_path):
-            return {}
-
-    with open(metadata_full_path, 'r') as f:
-        presets = json5.load(f)
-
-    return presets
-
-# return system voice presets and session voice presets individually, each in a list
-def get_voice_presets(session_id):
-    system_presets, session_presets = [], []
-
-    # Load system presets
-    system_presets = load_voice_presets_metadata(utils.get_system_voice_preset_path())
-
-    # Load session presets
-    session_presets = load_voice_presets_metadata(
-        utils.get_session_voice_preset_path(session_id),
-        safe_if_metadata_not_exist=True
-    )
-
-    return system_presets, session_presets
-
-# return merged voice presets in a {voice_preset_name: voice_preset} dict
-def get_merged_voice_presets(session_id):
-    system_presets, session_presets = get_voice_presets(session_id)
-    res = {}
-    for preset in list(system_presets.values()) + list(session_presets.values()):
-        res[preset['id']] = preset  # session presets with the same id will cover that of system presets
-    return res
-
-def add_voice_preset(voice_presets_path, presets, id, desc, wav_file_path):
-    if id in presets:
-        raise KeyError(f'{id} already in voice preset, path={voice_presets_path}!')
-
-    # Convert wav to npz
-    npz_path = voice_presets_path / 'npz'
-    VP(wav_file_path, npz_path)
-    npz_file_path = npz_path / f'{Path(wav_file_path).stem}.npz'
-
-    presets[id]  = {
-        'id': id,
-        'desc': desc,
-        'npz_path': str(npz_file_path)
-    }
-    save_voice_presets_metadata(voice_presets_path, presets)
-    return presets[id]
-
-def add_session_voice_preset(id, desc, wav_file_path, session_id):
-    voice_presets_path = utils.get_session_voice_preset_path(session_id)
-    os.makedirs(voice_presets_path / 'npz', exist_ok=True)
-    presets = load_voice_presets_metadata(voice_presets_path, safe_if_metadata_not_exist=True)
-    if len(presets) >= 3:
-        raise ValueError(f'session voice presets size exceed 3')
-    if id in presets:
-        raise KeyError(f'{id} already in voice preset, path={voice_presets_path}!')
-
-    return add_voice_preset(voice_presets_path, presets, id, desc, wav_file_path)
-
-def add_system_voice_preset(id, desc, wav_file_path):
-    voice_presets_path = utils.get_system_voice_preset_path()
-    presets = load_voice_presets_metadata(voice_presets_path)
-    return add_voice_preset(voice_presets_path, presets, id, desc, wav_file_path)
-
-# if session_id set to '', we are removing system voice presets
-def remove_session_voice_preset(id, session_id):
-    voice_presets_path = utils.get_session_voice_preset_path(session_id)
-    presets = load_voice_presets_metadata(
-        voice_presets_path,
-        safe_if_metadata_not_exist=True
-    )
-    preset = presets.pop(id)
-    npz_path = preset['npz_path']
-
-    try:
-        os.remove(npz_path)
-    except FileNotFoundError:
-        print(f"INFO: trying to delete {npz_path} which does not exist, path={voice_presets_path}.")
-
-    save_voice_presets_metadata(voice_presets_path, presets)
\ No newline at end of file
diff --git a/spaces/B10915003/B10915003-autotrain-jimmy-test-face-identification-53251125423/README.md b/spaces/B10915003/B10915003-autotrain-jimmy-test-face-identification-53251125423/README.md
deleted file mode 100644
index a9ab63e3f27464e7178821e9537fcec13c51cc41..0000000000000000000000000000000000000000
--- a/spaces/B10915003/B10915003-autotrain-jimmy-test-face-identification-53251125423/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: B10915003 Autotrain Jimmy Test Face Identification 53251125423
-emoji: 👁
-colorFrom: green
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.27.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/BAAI/dreambooth-altdiffusion/app.py b/spaces/BAAI/dreambooth-altdiffusion/app.py
deleted file mode 100644
index 80a9d1812ffb28057624ca9e77d6376afd4325cd..0000000000000000000000000000000000000000
--- a/spaces/BAAI/dreambooth-altdiffusion/app.py
+++ /dev/null
@@ -1,654 +0,0 @@
-import gradio as gr
-import os
-from pathlib import Path
-import argparse
-import shutil
-from train_dreambooth import run_training
-from convertosd import convert
-from PIL import Image
-from slugify import slugify
-import requests
-import torch
-import zipfile
-import tarfile
-import urllib.parse
-import gc
-# from diffusers import StableDiffusionPipeline
-from huggingface_hub import snapshot_download
-
-
-is_spaces = True if "SPACE_ID" in os.environ else False
-is_shared_ui = True if "IS_SHARED_UI" in os.environ else False
-is_gpu_associated = torch.cuda.is_available()
-
-css = '''
-    .instruction{position: absolute; top: 0;right: 0;margin-top: 0px !important}
-    .arrow{position: absolute;top: 0;right: -110px;margin-top: -8px !important}
-    #component-4, #component-3, #component-10{min-height: 0}
-    .duplicate-button img{margin: 0}
-'''
-maximum_concepts = 3
-
-#Pre download the files
-if(is_gpu_associated):
-    model_v1 = snapshot_download(repo_id="multimodalart/sd-fine-tunable")
-    model_v2 = snapshot_download(repo_id="stabilityai/stable-diffusion-2")
-    model_v2_512 = snapshot_download(repo_id="stabilityai/stable-diffusion-2-base")
-    model_alt = snapshot_download(repo_id="BAAI/AltDiffusion")
-    model_alt_m9 = snapshot_download(repo_id="BAAI/AltDiffusion-m9")
-    safety_checker = snapshot_download(repo_id="multimodalart/sd-sc")
-    model_to_load = model_alt_m9
-with zipfile.ZipFile("mix.zip", 'r') as zip_ref:
-    zip_ref.extractall(".")
-
-def swap_text(option, base):
-    resize_width = 768 if base == "v2-768" else 512
-    mandatory_liability = "You must have the right to do so and you are liable for the images you use, example:"
-    if(option == "object"):
-        instance_prompt_example = "cttoy"
-        freeze_for = 30
-        return [f"You are going to train `object`(s), upload 5-10 images of each object you are planning on training on from different angles/perspectives. You can use services like <a style='text-decoration: underline' target='_blank' href='https://www.birme.net/?target_width={resize_width}&target_height={resize_width}'>birme</a> for smart cropping. {mandatory_liability}:", '''<img src="https://raw.githubusercontent.com/superhero-7/img_bank/main/Naruto.png" />''', f"You should name your concept with a unique made up word that has low chance of the model already knowing it (e.g.: `{instance_prompt_example}` here). Images will be automatically cropped to {resize_width}x{resize_width}.", freeze_for, gr.update(visible=False)]
-    elif(option == "person"):
-       instance_prompt_example = "julcto"
-       freeze_for = 70
-       #show_prior_preservation = True if base != "v2-768" else False
-       show_prior_preservation=False
-       if(show_prior_preservation):
-           prior_preservation_box_update = gr.update(visible=show_prior_preservation)
-       else: 
-           prior_preservation_box_update = gr.update(visible=show_prior_preservation, value=False)
-       return [f"You are going to train a `person`(s), upload 10-20 images of each person you are planning on training on from different angles/perspectives. You can use services like <a style='text-decoration: underline' target='_blank' href='https://www.birme.net/?target_width={resize_width}&target_height={resize_width}'>birme</a> for smart cropping. {mandatory_liability}:", '''<img src="https://raw.githubusercontent.com/superhero-7/img_bank/main/cxk.png" />''', f"You should name your concept with a unique made up word that has low chance of the model already knowing it (e.g.: `{instance_prompt_example}` here). Images will be automatically cropped to {resize_width}x{resize_width}.", freeze_for, prior_preservation_box_update]
-    elif(option == "style"):
-        instance_prompt_example = "trsldamrl"
-        freeze_for = 10
-        return [f"You are going to train a `style`, upload 10-20 images of the style you are planning on training on. You can use services like <a style='text-decoration: underline' target='_blank' href='https://www.birme.net/?target_width={resize_width}&target_height={resize_width}'>birme</a> for smart cropping. Name the files with the words you would like  {mandatory_liability}:", '''<img src="file/trsl_style.png" />''', f"You should name your concept with a unique made up word that has low chance of the model already knowing it (e.g.: `{instance_prompt_example}` here). Images will be automatically cropped to {resize_width}x{resize_width}", freeze_for, gr.update(visible=False)]
-
-def swap_base_model(selected_model):
-    if(is_gpu_associated):
-        global model_to_load
-        # if(selected_model == "v1-5"):
-        #     model_to_load = model_v1
-        # elif(selected_model == "v2-768"):
-        #     model_to_load = model_v2
-        # elif(selected_model == "alt"):
-        #     model_to_load = model_alt
-        # elif(selected_model == "alt_m9"):
-        #     model_to_load = model_alt_m9
-        # else:
-        #     model_to_load = model_v2_512
-        if(selected_model == "alt"):
-            model_to_load = model_alt
-
-def count_files(*inputs):
-    file_counter = 0
-    concept_counter = 0
-    for i, input in enumerate(inputs):
-        if(i < maximum_concepts-1):
-            files = inputs[i]
-            if(files):
-                concept_counter+=1
-                file_counter+=len(files)
-    uses_custom = inputs[-1] 
-    type_of_thing = inputs[-4]
-    selected_model = inputs[-5]
-    experimental_faces = inputs[-6]
-    if(uses_custom):
-        Training_Steps = int(inputs[-3])
-    else:
-        Training_Steps = file_counter*150
-        if(type_of_thing == "person" and Training_Steps > 2400):
-            Training_Steps = 2400 #Avoid overfitting on person faces
-    if(is_spaces):
-        if(selected_model == "v1-5" or selected_model == "alt" or selected_model == "alt_m9"):
-            its = 1.1
-            if(experimental_faces):
-                its = 1
-        elif(selected_model == "v2-512"):
-            its = 0.8
-            if(experimental_faces):
-                its = 0.7
-        elif(selected_model == "v2-768"):
-            its = 0.5
-        summary_sentence = f'''You are going to train {concept_counter} {type_of_thing}(s), with {file_counter} images for {Training_Steps} steps. The training should take around {round(Training_Steps/its, 2)} seconds, or {round((Training_Steps/its)/60, 2)} minutes.
-            The setup, compression and uploading the model can take up to 20 minutes.<br>As the T4-Small GPU costs US$0.60 for 1h, <span style="font-size: 120%"><b>the estimated cost for this training is below US${round((((Training_Steps/its)/3600)+0.3+0.1)*0.60, 2)}.</b></span><br><br>
-            If you check the box below the GPU attribution will automatically removed after training is done and the model is uploaded. If not, don't forget to come back here and swap the hardware back to CPU.<br><br>'''
-    else:
-        summary_sentence = f'''You are going to train {concept_counter} {type_of_thing}(s), with {file_counter} images for {Training_Steps} steps.<br><br>'''
-        
-    return([gr.update(visible=True), gr.update(visible=True, value=summary_sentence)])
-
-def update_steps(*files_list):
-    file_counter = 0
-    for i, files in enumerate(files_list):
-        if(files):
-            file_counter+=len(files)
-    return(gr.update(value=file_counter*200))
-
-def pad_image(image):
-    w, h = image.size
-    if w == h:
-        return image
-    elif w > h:
-        new_image = Image.new(image.mode, (w, w), (0, 0, 0))
-        new_image.paste(image, (0, (w - h) // 2))
-        return new_image
-    else:
-        new_image = Image.new(image.mode, (h, h), (0, 0, 0))
-        new_image.paste(image, ((h - w) // 2, 0))
-        return new_image
-
-def train(*inputs):
-    if is_shared_ui:
-        raise gr.Error("This Space only works in duplicated instances")
-    if not is_gpu_associated:
-        raise gr.Error("Please associate a T4 GPU for this Space")
-    torch.cuda.empty_cache()
-    if 'pipe' in globals():
-        global pipe, pipe_is_set
-        del pipe
-        pipe_is_set = False
-        gc.collect()
-        
-    if os.path.exists("output_model"): shutil.rmtree('output_model')
-    if os.path.exists("instance_images"): shutil.rmtree('instance_images')
-    if os.path.exists("diffusers_model.tar"): os.remove("diffusers_model.tar")
-    if os.path.exists("model.ckpt"): os.remove("model.ckpt")
-    if os.path.exists("hastrained.success"): os.remove("hastrained.success")
-    file_counter = 0
-    which_model = inputs[-10]
-    resolution = 512 if which_model != "v2-768" else 768
-    for i, input in enumerate(inputs):
-        if(i < maximum_concepts-1):
-            if(input):
-                os.makedirs('instance_images',exist_ok=True)
-                files = inputs[i+(maximum_concepts*2)]
-                prompt = inputs[i+maximum_concepts]
-                if(prompt == "" or prompt == None):
-                    raise gr.Error("You forgot to define your concept prompt")
-                for j, file_temp in enumerate(files):
-                    file = Image.open(file_temp.name)
-                    image = pad_image(file)
-                    image = image.resize((resolution, resolution))
-                    extension = file_temp.name.split(".")[1]
-                    image = image.convert('RGB')
-                    image.save(f'instance_images/{prompt}_({j+1}).jpg', format="JPEG", quality = 100)
-                    file_counter += 1
-    
-    os.makedirs('output_model',exist_ok=True)
-    uses_custom = inputs[-1] 
-    type_of_thing = inputs[-4]
-    remove_attribution_after = inputs[-6]
-    experimental_face_improvement = inputs[-9]
-    
-    if(uses_custom):
-        Training_Steps = int(inputs[-3])
-        Train_text_encoder_for = int(inputs[-2])
-    else:
-        if(type_of_thing == "object"):
-            Train_text_encoder_for=30
-            
-        elif(type_of_thing == "style"):
-            Train_text_encoder_for=15
-            
-        elif(type_of_thing == "person"):
-            Train_text_encoder_for=70
-        
-        Training_Steps = file_counter*150
-        if(type_of_thing == "person" and Training_Steps > 2600):
-            Training_Steps = 2600 #Avoid overfitting on people's faces
-    stptxt = int((Training_Steps*Train_text_encoder_for)/100)
-    gradient_checkpointing = True if (experimental_face_improvement or which_model != "v1-5") else False 
-    cache_latents = True if which_model != "v1-5" else False
-    if (type_of_thing == "object" or type_of_thing == "style" or (type_of_thing == "person" and not experimental_face_improvement)):
-        args_general = argparse.Namespace(
-            image_captions_filename = True,
-            train_text_encoder = True if stptxt > 0 else False,
-            stop_text_encoder_training = stptxt,
-            save_n_steps = 0,
-            pretrained_model_name_or_path = model_to_load,
-            instance_data_dir="instance_images",
-            class_data_dir=None,
-            output_dir="output_model",
-            instance_prompt="",
-            seed=42,
-            resolution=resolution,
-            mixed_precision="fp16",
-            train_batch_size=1,
-            gradient_accumulation_steps=1,
-            use_8bit_adam=True,
-            learning_rate=2e-6,
-            lr_scheduler="polynomial",
-            lr_warmup_steps = 0,
-            max_train_steps=Training_Steps,     
-            gradient_checkpointing=gradient_checkpointing,
-            cache_latents=cache_latents,
-        )
-        print("Starting single training...")
-        lock_file = open("intraining.lock", "w")
-        lock_file.close()
-        run_training(args_general)
-    else:
-        args_general = argparse.Namespace(
-            image_captions_filename = True,
-            train_text_encoder = True if stptxt > 0 else False,
-            stop_text_encoder_training = stptxt,
-            save_n_steps = 0,
-            pretrained_model_name_or_path = model_to_load,
-            instance_data_dir="instance_images",
-            class_data_dir="Mix",
-            output_dir="output_model",
-            with_prior_preservation=True,
-            prior_loss_weight=1.0,
-            instance_prompt="",
-            seed=42,
-            resolution=resolution,
-            mixed_precision="fp16",
-            train_batch_size=1,
-            gradient_accumulation_steps=1,
-            use_8bit_adam=True,
-            learning_rate=2e-6,
-            lr_scheduler="polynomial",
-            lr_warmup_steps = 0,
-            max_train_steps=Training_Steps,
-            num_class_images=200,     
-            gradient_checkpointing=gradient_checkpointing,
-            cache_latents=cache_latents,
-        )
-        print("Starting multi-training...")
-        lock_file = open("intraining.lock", "w")
-        lock_file.close()
-        run_training(args_general)
-    gc.collect()
-    torch.cuda.empty_cache()
-    if(which_model == "v1-5"):
-        print("Adding Safety Checker to the model...")
-        shutil.copytree(f"{safety_checker}/feature_extractor", "output_model/feature_extractor")
-        shutil.copytree(f"{safety_checker}/safety_checker", "output_model/safety_checker")
-        shutil.copy(f"model_index.json", "output_model/model_index.json")
-    
-    if(not remove_attribution_after):
-        print("Archiving model file...")
-        with tarfile.open("diffusers_model.tar", "w") as tar:
-            tar.add("output_model", arcname=os.path.basename("output_model"))
-        if os.path.exists("intraining.lock"): os.remove("intraining.lock")
-        trained_file = open("hastrained.success", "w")
-        trained_file.close()
-        print("Training completed!")
-        return [
-            gr.update(visible=True, value=["diffusers_model.tar"]), #result
-            gr.update(visible=True), #try_your_model
-            gr.update(visible=True), #push_to_hub
-            gr.update(visible=True), #convert_button
-            gr.update(visible=False), #training_ongoing
-            gr.update(visible=True) #completed_training
-        ]
-    else:
-        hf_token = inputs[-5]
-        model_name = inputs[-7]
-        where_to_upload = inputs[-8]
-        push(model_name, where_to_upload, hf_token, which_model, True)
-        hardware_url = f"https://huggingface.co/spaces/{os.environ['SPACE_ID']}/hardware"
-        headers = { "authorization" : f"Bearer {hf_token}"}
-        body = {'flavor': 'cpu-basic'}
-        requests.post(hardware_url, json = body, headers=headers)
-
-pipe_is_set = False
-def generate(prompt, steps):
-    torch.cuda.empty_cache()
-    # from diffusers import StableDiffusionPipeline
-    from diffusers import DiffusionPipeline
-    global pipe_is_set
-    if(not pipe_is_set):
-        global pipe
-        # pipe = StableDiffusionPipeline.from_pretrained("./output_model", torch_dtype=torch.float16)
-        pipe = DiffusionPipeline.from_pretrained("./output_model", torch_dtype=torch.float16)
-        pipe = pipe.to("cuda")
-        pipe_is_set = True
-        
-    image = pipe(prompt, num_inference_steps=steps).images[0]  
-    return(image)
-    
-def push(model_name, where_to_upload, hf_token, which_model, comes_from_automated=False):
-    if(not os.path.exists("model.ckpt")):
-        convert("output_model", "model.ckpt")
-    from huggingface_hub import HfApi, HfFolder, CommitOperationAdd
-    from huggingface_hub import create_repo
-    model_name_slug = slugify(model_name)
-    api = HfApi()
-    your_username = api.whoami(token=hf_token)["name"]
-    if(where_to_upload == "My personal profile"):    
-        model_id = f"{your_username}/{model_name_slug}"
-    else:
-        model_id = f"sd-dreambooth-library/{model_name_slug}"
-        headers = {"Authorization" : f"Bearer: {hf_token}", "Content-Type": "application/json"}
-        response = requests.post("https://huggingface.co/organizations/sd-dreambooth-library/share/SSeOwppVCscfTEzFGQaqpfcjukVeNrKNHX", headers=headers)
-    
-    images_upload = os.listdir("instance_images")
-    image_string = ""
-    instance_prompt_list = []
-    previous_instance_prompt = ''
-    for i, image in enumerate(images_upload):
-        instance_prompt = image.split("_")[0]
-        if(instance_prompt != previous_instance_prompt):
-            title_instance_prompt_string = instance_prompt
-            instance_prompt_list.append(instance_prompt)
-        else:
-            title_instance_prompt_string = ''
-        previous_instance_prompt = instance_prompt
-        image_string = f'''{title_instance_prompt_string} {"(use that on your prompt)" if title_instance_prompt_string != "" else ""} 
-{image_string}![{instance_prompt} {i}](https://huggingface.co/{model_id}/resolve/main/concept_images/{urllib.parse.quote(image)})'''
-    readme_text = f'''---
-license: creativeml-openrail-m
-tags:
-- text-to-image
-widget:
-- text: {instance_prompt_list[0]}
----
-### {model_name} Dreambooth model trained by {api.whoami(token=hf_token)["name"]} with [Hugging Face Dreambooth Training Space](https://huggingface.co/spaces/multimodalart/dreambooth-training) with the {which_model} base model
-
-You run your new concept via `diffusers` [Colab Notebook for Inference](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/sd_dreambooth_inference.ipynb). Don't forget to use the concept prompts! 
-
-Sample pictures of:
-{image_string}
-'''
-    #Save the readme to a file
-    readme_file = open("model.README.md", "w")
-    readme_file.write(readme_text)
-    readme_file.close()
-    #Save the token identifier to a file
-    text_file = open("token_identifier.txt", "w")
-    text_file.write(', '.join(instance_prompt_list))
-    text_file.close()
-    try:
-        create_repo(model_id,private=True, token=hf_token)
-    except:
-        import time
-        epoch_time = str(int(time.time()))
-        create_repo(f"{model_id}-{epoch_time}", private=True,token=hf_token)
-    operations = [
-        CommitOperationAdd(path_in_repo="token_identifier.txt", path_or_fileobj="token_identifier.txt"),
-        CommitOperationAdd(path_in_repo="README.md", path_or_fileobj="model.README.md"),
-        CommitOperationAdd(path_in_repo=f"model.ckpt",path_or_fileobj="model.ckpt")
-    ]
-    api.create_commit(
-    repo_id=model_id,
-    operations=operations,
-    commit_message=f"Upload the model {model_name}",
-    token=hf_token
-    )
-    api.upload_folder(
-    folder_path="output_model",
-    repo_id=model_id,
-    token=hf_token
-    )
-    api.upload_folder(
-    folder_path="instance_images",
-    path_in_repo="concept_images",
-    repo_id=model_id,
-    token=hf_token
-    )
-    if is_spaces:
-        if(not comes_from_automated):
-            extra_message = "Don't forget to remove the GPU attribution after you play with it."
-        else:
-            extra_message = "The GPU has been removed automatically as requested, and you can try the model via the model page"
-        api.create_discussion(repo_id=os.environ['SPACE_ID'], title=f"Your model {model_name} has finished trained from the Dreambooth Train Spaces!", description=f"Your model has been successfully uploaded to: https://huggingface.co/{model_id}. {extra_message}",repo_type="space", token=hf_token)
-
-    return [gr.update(visible=True, value=f"Successfully uploaded your model. Access it [here](https://huggingface.co/{model_id})"), gr.update(visible=True, value=["diffusers_model.tar", "model.ckpt"])]
-
-def convert_to_ckpt():
-    if 'pipe' in globals():
-        global pipe, pipe_is_set
-        del pipe
-        pipe_is_set = False
-        gc.collect()
-    convert("output_model", "model.ckpt")
-    return gr.update(visible=True, value=["diffusers_model.tar", "model.ckpt"])
-
-def check_status(top_description):
-    if os.path.exists("hastrained.success"):
-        if is_spaces:
-            update_top_tag = gr.update(value=f'''
-            <div class="gr-prose" style="max-width: 80%">
-                <h2>Your model has finished training ✅</h2>
-                <p>Yay, congratulations on training your model. Scroll down to play with with it, save it (either downloading it or on the Hugging Face Hub). Once you are done, your model is safe, and you don't want to train a new one, go to the <a href="https://huggingface.co/spaces/{os.environ['SPACE_ID']}" target="_blank">settings page</a> and downgrade your Space to a CPU Basic</p> 
-            </div>
-            ''')
-        else:
-            update_top_tag = gr.update(value=f'''
-            <div class="gr-prose" style="max-width: 80%">
-                <h2>Your model has finished training ✅</h2>
-                <p>Yay, congratulations on training your model. Scroll down to play with with it, save it (either downloading it or on the Hugging Face Hub).</p> 
-            </div>
-            ''')
-        show_outputs = True
-    elif os.path.exists("intraining.lock"):
-        update_top_tag = gr.update(value='''
-        <div class="gr-prose" style="max-width: 80%">
-            <h2>Don't worry, your model is still training! ⌛</h2>
-            <p>You closed the tab while your model was training, but it's all good! It is still training right now. You can click the "Open logs" button above here to check the training status. Once training is done, reload this tab to interact with your model</p> 
-        </div>
-        ''')
-        show_outputs = False
-    else:
-        update_top_tag = gr.update(value=top_description)
-        show_outputs = False
-    if os.path.exists("diffusers_model.tar"):
-       update_files_tag = gr.update(visible=show_outputs, value=["diffusers_model.tar"])
-    else:
-       update_files_tag = gr.update(visible=show_outputs)
-    return [
-        update_top_tag, #top_description
-        gr.update(visible=show_outputs), #try_your_model
-        gr.update(visible=show_outputs), #push_to_hub
-        update_files_tag, #result
-        gr.update(visible=show_outputs), #convert_button
-    ]
-
-def checkbox_swap(checkbox):
-    return [gr.update(visible=checkbox), gr.update(visible=checkbox), gr.update(visible=checkbox), gr.update(visible=checkbox)]
-
-with gr.Blocks(css=css) as demo:
-    with gr.Box():
-        gr.HTML(f'''
-            <div style="text-align: center; max-width: 650px; margin: 0 auto;">
-            <div
-            style="
-                display: inline-flex;
-                gap: 1.2rem;
-                font-size: 1.75rem;
-                margin-bottom: 40px;
-                width: 150px;
-                margin: 0 auto;
-                justify-content: center;
-            ">
-            <a href="https://github.com/FlagAI-Open/FlagAI"><img src="https://raw.githubusercontent.com/FlagAI-Open/FlagAI/master/logo.png" alt="FlagAI" width="80%" style="margin: 0 auto;"></a>
-            </div>
-            <br />
-            <h1 style="font-weight: 2200; margin-bottom: 15px; margin-top: 15px; font-size: 2.7rem;">
-            Dreambooth Web UI
-            </h1>
-            <br />
-            <a class="duplicate-button" style="display:inline-block" target="_blank" href="https://huggingface.co/spaces/{os.environ['SPACE_ID']}?duplicate=true"><img src="https://img.shields.io/badge/-Duplicate%20Space-blue?labelColor=white&style=flat&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAP5JREFUOE+lk7FqAkEURY+ltunEgFXS2sZGIbXfEPdLlnxJyDdYB62sbbUKpLbVNhyYFzbrrA74YJlh9r079973psed0cvUD4A+4HoCjsA85X0Dfn/RBLBgBDxnQPfAEJgBY+A9gALA4tcbamSzS4xq4FOQAJgCDwV2CPKV8tZAJcAjMMkUe1vX+U+SMhfAJEHasQIWmXNN3abzDwHUrgcRGmYcgKe0bxrblHEB4E/pndMazNpSZGcsZdBlYJcEL9Afo75molJyM2FxmPgmgPqlWNLGfwZGG6UiyEvLzHYDmoPkDDiNm9JR9uboiONcBXrpY1qmgs21x1QwyZcpvxt9NS09PlsPAAAAAElFTkSuQmCC&logoWidth=14" alt="Duplicate Space"></a>
-            <p style="margin-bottom: 15px; margin-top: 15px; font-size: 94%">
-            This is a dreambooth Training UI for <a href="https://huggingface.co/BAAI/AltDiffusion-m9" style="text-decoration: underline;">AltDiffusion-m9 model</a>,which is a multilingual image-to-text model supported 9 languages.
-            You can duplicate this space to your own!
-            </p>
-            </div> 
-                ''')
-        with gr.Box():
-            if is_shared_ui:
-                top_description = gr.HTML(f'''
-                    <div class="gr-prose" style="max-width: 80%">
-                    <h2>Attention - This Space doesn't work in this shared UI</h2>
-                    <p>For it to work, you can either run locally or duplicate the Space and run it on your own profile using a (paid) private T4 GPU for training. As each T4 costs US$0.60/h, it should cost < US$1 to train most models using default settings!&nbsp;&nbsp;<a class="duplicate-button" style="display:inline-block" target="_blank" href="https://huggingface.co/spaces/{os.environ['SPACE_ID']}?duplicate=true"><img src="https://img.shields.io/badge/-Duplicate%20Space-blue?labelColor=white&style=flat&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAP5JREFUOE+lk7FqAkEURY+ltunEgFXS2sZGIbXfEPdLlnxJyDdYB62sbbUKpLbVNhyYFzbrrA74YJlh9r079973psed0cvUD4A+4HoCjsA85X0Dfn/RBLBgBDxnQPfAEJgBY+A9gALA4tcbamSzS4xq4FOQAJgCDwV2CPKV8tZAJcAjMMkUe1vX+U+SMhfAJEHasQIWmXNN3abzDwHUrgcRGmYcgKe0bxrblHEB4E/pndMazNpSZGcsZdBlYJcEL9Afo75molJyM2FxmPgmgPqlWNLGfwZGG6UiyEvLzHYDmoPkDDiNm9JR9uboiONcBXrpY1qmgs21x1QwyZcpvxt9NS09PlsPAAAAAElFTkSuQmCC&logoWidth=14" alt="Duplicate Space"></a></p>
-                    <img class="instruction" src="file/duplicate.png"> 
-                    <img class="arrow" src="file/arrow.png" />
-                    </div>
-                ''')
-            elif(is_spaces):
-                if(is_gpu_associated):
-                    top_description = gr.HTML(f'''
-                            <div class="gr-prose" style="max-width: 80%">
-                            <h2>You have successfully associated a GPU to the Dreambooth Training Space 🎉</h2>
-                            <p>Certify that you got a T4. You can now train your model! You will be billed by the minute from when you activated the GPU until when it is turned it off.</p> 
-                            </div>
-                    ''')
-                else:
-                    top_description = gr.HTML(f'''
-                            <div class="gr-prose" style="max-width: 80%">
-                            <h2>You have successfully duplicated the Dreambooth Training Space 🎉</h2>
-                            <p>There's only one step left before you can train your model: <a href="https://huggingface.co/spaces/{os.environ['SPACE_ID']}/settings" style="text-decoration: underline" target="_blank">attribute a <b>T4 GPU</b> to it (via the Settings tab)</a> and run the training below. Other GPUs are not compatible for now. You will be billed by the minute from when you activate the GPU until when it is turned it off.</p> 
-                            </div>
-                    ''')
-            else:
-                top_description = gr.HTML(f'''
-                        <div class="gr-prose" style="max-width: 80%">
-                        <h2>You have successfully cloned the Dreambooth Training Space locally 🎉</h2>
-                        <p>Do a <code>pip install requirements-local.txt</code></p> 
-                        </div>
-                    ''')
-
-    # gr.Markdown("# Dreambooth Training UI 💭")
-    gr.Markdown("Customize AltDiffusion and AltDiffusion-m9(ⁿᵉʷ!) by giving it a few examples of a concept. Based on the [🧨 diffusers](https://github.com/huggingface/diffusers) implementation, additional techniques from [TheLastBen](https://github.com/TheLastBen/diffusers) and [ShivamShrirao](https://github.com/ShivamShrirao/diffusers)")
-    
-    with gr.Row() as what_are_you_training:
-        type_of_thing = gr.Dropdown(label="What would you like to train?", choices=["object", "person", "style"], value="object", interactive=True)
-        base_model_to_use = gr.Dropdown(label="Which base model would you like to use?", choices=["alt", "alt_m9"], value="alt_m9", interactive=True)
-    
-    #Very hacky approach to emulate dynamically created Gradio components   
-    with gr.Column() as upload_your_concept:
-        with gr.Box():
-            thing_description = gr.Markdown("You are going to train an `object`, please upload 5-10 images of the object you are planning on training on from different angles/perspectives. You must have the right to do so and you are liable for the images you use, example")
-            thing_experimental = gr.Checkbox(label="Improve faces (prior preservation) - can take longer training but can improve faces", visible=False, value=False)
-            thing_image_example = gr.HTML('''<img src="https://raw.githubusercontent.com/superhero-7/img_bank/main/Naruto.png" />''')
-            things_naming = gr.Markdown("You should name your concept with a unique made up word that has low chance of the model already knowing it (e.g.: `UzNrto` here). Images will be automatically cropped to 512x512.")
-            
-        # with gr.Column():
-        file_collection = []
-        concept_collection = []
-        buttons_collection = []
-        delete_collection = []
-        is_visible = []
-
-        row = [None] * maximum_concepts
-        for x in range(maximum_concepts):
-            ordinal = lambda n: "%d%s" % (n, "tsnrhtdd"[(n // 10 % 10 != 1) * (n % 10 < 4) * n % 10::4])
-            if(x == 0):
-                visible = True
-                is_visible.append(gr.State(value=True))
-            else:
-                visible = False
-                is_visible.append(gr.State(value=False))
-
-            file_collection.append(gr.File(label=f'''Upload the images for your {ordinal(x+1) if (x>0) else ""} concept''', file_count="multiple", interactive=True, visible=visible))
-            with gr.Column(visible=visible) as row[x]:
-                concept_collection.append(gr.Textbox(label=f'''{ordinal(x+1) if (x>0) else ""} concept prompt - use a unique, made up word to avoid collisions'''))  
-                with gr.Row():
-                    if(x < maximum_concepts-1):
-                        buttons_collection.append(gr.Button(value="Add +1 concept", visible=visible))
-                    if(x > 0):
-                        delete_collection.append(gr.Button(value=f"Delete {ordinal(x+1)} concept"))
-        
-        counter_add = 1
-        for button in buttons_collection:
-            if(counter_add < len(buttons_collection)):
-                button.click(lambda:
-                [gr.update(visible=True),gr.update(visible=True), gr.update(visible=False), gr.update(visible=True), True, None],
-                None, 
-                [row[counter_add], file_collection[counter_add], buttons_collection[counter_add-1], buttons_collection[counter_add], is_visible[counter_add], file_collection[counter_add]], queue=False)
-            else:
-                button.click(lambda:[gr.update(visible=True),gr.update(visible=True), gr.update(visible=False), True], None, [row[counter_add], file_collection[counter_add], buttons_collection[counter_add-1], is_visible[counter_add]], queue=False)
-            counter_add += 1
-        
-        counter_delete = 1
-        for delete_button in delete_collection:
-            if(counter_delete < len(delete_collection)+1):
-                delete_button.click(lambda:[gr.update(visible=False),gr.update(visible=False), gr.update(visible=True), False], None, [file_collection[counter_delete], row[counter_delete], buttons_collection[counter_delete-1], is_visible[counter_delete]], queue=False)
-            counter_delete += 1
-                  
-    with gr.Accordion("Custom Settings", open=False):
-        swap_auto_calculated = gr.Checkbox(label="Use custom settings")
-        gr.Markdown("If not checked, the % of frozen encoder will be tuned automatically to whether you are training an `object`, `person` or `style`. The text-encoder is frozen after 10% of the steps for a style, 30% of the steps for an object and 75% trained for persons. The number of steps varies between 1400 and 2400 depending on how many images uploaded. If you see too many artifacts in your output, it means it may have overfit and you need less steps. If your results aren't really what you wanted, it may be underfitting and you need more steps.")
-        steps = gr.Number(label="How many steps", value=2400)
-        perc_txt_encoder = gr.Number(label="Percentage of the training steps the text-encoder should be trained as well", value=30)
-        
-    with gr.Box(visible=False) as training_summary:
-        training_summary_text = gr.HTML("", visible=True, label="Training Summary")
-        is_advanced_visible = True if is_spaces else False
-        training_summary_checkbox = gr.Checkbox(label="Automatically remove paid GPU attribution and upload model to the Hugging Face Hub after training", value=True, visible=is_advanced_visible)
-        training_summary_model_name = gr.Textbox(label="Name of your model", visible=True)
-        training_summary_where_to_upload = gr.Dropdown(["My personal profile", "Public Library"], value="My personal profile", label="Upload to", visible=True)
-        training_summary_token_message = gr.Markdown("[A Hugging Face write access token](https://huggingface.co/settings/tokens), go to \"New token\" -> Role : Write. A regular read token won't work here.", visible=True)            
-        training_summary_token = gr.Textbox(label="Hugging Face Write Token", type="password", visible=True)
-        
-    train_btn = gr.Button("Start Training")
-    if(is_shared_ui):
-        training_ongoing = gr.Markdown("## This Space only works in duplicated instances. Please duplicate it and try again!", visible=False)
-    elif(not is_gpu_associated):
-        training_ongoing = gr.Markdown("## Oops, you haven't associated your T4 GPU to this Space. Visit the Settings tab, associate and try again.", visible=False)
-    else:
-        training_ongoing = gr.Markdown("## Training is ongoing ⌛... You can close this tab if you like or just wait. If you did not check the `Remove GPU After training`, you can come back here to try your model and upload it after training. Don't forget to remove the GPU attribution after you are done. ", visible=False)
-    
-    #Post-training UI
-    completed_training = gr.Markdown('''# ✅ Training completed. 
-    ### Don't forget to remove the GPU attribution after you are done trying and uploading your model''', visible=False)
-    
-    with gr.Row():
-        with gr.Box(visible=False) as try_your_model:
-            gr.Markdown("## Try your model")
-            prompt = gr.Textbox(label="Type your prompt")
-            result_image = gr.Image()
-            inference_steps = gr.Slider(minimum=1, maximum=150, value=50, step=1)
-            generate_button = gr.Button("Generate Image")
-        
-        with gr.Box(visible=False) as push_to_hub:
-            gr.Markdown("## Push to Hugging Face Hub")
-            model_name = gr.Textbox(label="Name of your model", placeholder="Tarsila do Amaral Style")
-            where_to_upload = gr.Dropdown(["My personal profile", "Public Library"], label="Upload to")
-            gr.Markdown("[A Hugging Face write access token](https://huggingface.co/settings/tokens), go to \"New token\" -> Role : Write. A regular read token won't work here.")
-            hf_token = gr.Textbox(label="Hugging Face Write Token", type="password")
-            
-            push_button = gr.Button("Push to the Hub")
-    
-    result = gr.File(label="Download the uploaded models in the diffusers format", visible=True)
-    success_message_upload = gr.Markdown(visible=False)
-    convert_button = gr.Button("Convert to CKPT", visible=False)
-    
-    #Swap the examples and the % of text encoder trained depending if it is an object, person or style
-    type_of_thing.change(fn=swap_text, inputs=[type_of_thing, base_model_to_use], outputs=[thing_description, thing_image_example, things_naming, perc_txt_encoder, thing_experimental], queue=False, show_progress=False)
-    
-    #Swap the base model
-    base_model_to_use.change(fn=swap_text, inputs=[type_of_thing, base_model_to_use], outputs=[thing_description, thing_image_example, things_naming, perc_txt_encoder, thing_experimental], queue=False, show_progress=False)
-    base_model_to_use.change(fn=swap_base_model, inputs=base_model_to_use, outputs=[])
-
-    #Update the summary box below the UI according to how many images are uploaded and whether users are using custom settings or not 
-    for file in file_collection:
-        #file.change(fn=update_steps,inputs=file_collection, outputs=steps)
-        file.change(fn=count_files, inputs=file_collection+[thing_experimental]+[base_model_to_use]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[training_summary, training_summary_text], queue=False)
-    
-    thing_experimental.change(fn=count_files, inputs=file_collection+[thing_experimental]+[base_model_to_use]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[training_summary, training_summary_text], queue=False)
-    base_model_to_use.change(fn=count_files, inputs=file_collection+[thing_experimental]+[base_model_to_use]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[training_summary, training_summary_text], queue=False)
-    steps.change(fn=count_files, inputs=file_collection+[thing_experimental]+[base_model_to_use]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[training_summary, training_summary_text], queue=False)
-    perc_txt_encoder.change(fn=count_files, inputs=file_collection+[thing_experimental]+[base_model_to_use]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[training_summary, training_summary_text], queue=False)
-    
-    #Give more options if the user wants to finish everything after training
-    if(is_spaces):
-        training_summary_checkbox.change(fn=checkbox_swap, inputs=training_summary_checkbox, outputs=[training_summary_token_message, training_summary_token, training_summary_model_name, training_summary_where_to_upload],queue=False, show_progress=False)
-    #Add a message for while it is in training
-    train_btn.click(lambda:gr.update(visible=True), inputs=None, outputs=training_ongoing)
-    
-    #The main train function
-    train_btn.click(fn=train, inputs=is_visible+concept_collection+file_collection+[base_model_to_use]+[thing_experimental]+[training_summary_where_to_upload]+[training_summary_model_name]+[training_summary_checkbox]+[training_summary_token]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[result, try_your_model, push_to_hub, convert_button, training_ongoing, completed_training], queue=False)
-    
-    #Button to generate an image from your trained model after training
-    generate_button.click(fn=generate, inputs=[prompt, inference_steps], outputs=result_image, queue=False)
-    #Button to push the model to the Hugging Face Hub
-    push_button.click(fn=push, inputs=[model_name, where_to_upload, hf_token, base_model_to_use], outputs=[success_message_upload, result], queue=False)
-    #Button to convert the model to ckpt format 
-    convert_button.click(fn=convert_to_ckpt, inputs=[], outputs=result, queue=False)
-    
-    #Checks if the training is running
-    demo.load(fn=check_status, inputs=top_description, outputs=[top_description, try_your_model, push_to_hub, result, convert_button], queue=False, show_progress=False)
-
-demo.queue(default_enabled=False).launch(debug=True)
\ No newline at end of file
diff --git a/spaces/Bart92/RVC_HF/infer/lib/uvr5_pack/lib_v5/model_param_init.py b/spaces/Bart92/RVC_HF/infer/lib/uvr5_pack/lib_v5/model_param_init.py
deleted file mode 100644
index b995c0bfb1194746187692e2ab1c2a6dbaaaec6c..0000000000000000000000000000000000000000
--- a/spaces/Bart92/RVC_HF/infer/lib/uvr5_pack/lib_v5/model_param_init.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import json
-import os
-import pathlib
-
-default_param = {}
-default_param["bins"] = 768
-default_param["unstable_bins"] = 9  # training only
-default_param["reduction_bins"] = 762  # training only
-default_param["sr"] = 44100
-default_param["pre_filter_start"] = 757
-default_param["pre_filter_stop"] = 768
-default_param["band"] = {}
-
-
-default_param["band"][1] = {
-    "sr": 11025,
-    "hl": 128,
-    "n_fft": 960,
-    "crop_start": 0,
-    "crop_stop": 245,
-    "lpf_start": 61,  # inference only
-    "res_type": "polyphase",
-}
-
-default_param["band"][2] = {
-    "sr": 44100,
-    "hl": 512,
-    "n_fft": 1536,
-    "crop_start": 24,
-    "crop_stop": 547,
-    "hpf_start": 81,  # inference only
-    "res_type": "sinc_best",
-}
-
-
-def int_keys(d):
-    r = {}
-    for k, v in d:
-        if k.isdigit():
-            k = int(k)
-        r[k] = v
-    return r
-
-
-class ModelParameters(object):
-    def __init__(self, config_path=""):
-        if ".pth" == pathlib.Path(config_path).suffix:
-            import zipfile
-
-            with zipfile.ZipFile(config_path, "r") as zip:
-                self.param = json.loads(
-                    zip.read("param.json"), object_pairs_hook=int_keys
-                )
-        elif ".json" == pathlib.Path(config_path).suffix:
-            with open(config_path, "r") as f:
-                self.param = json.loads(f.read(), object_pairs_hook=int_keys)
-        else:
-            self.param = default_param
-
-        for k in [
-            "mid_side",
-            "mid_side_b",
-            "mid_side_b2",
-            "stereo_w",
-            "stereo_n",
-            "reverse",
-        ]:
-            if not k in self.param:
-                self.param[k] = False
diff --git a/spaces/Benson/text-generation/Examples/Baku Burger House.md b/spaces/Benson/text-generation/Examples/Baku Burger House.md
deleted file mode 100644
index 44cb34aaba2d7a77f60af7fea0ede84e580def18..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Baku Burger House.md	
+++ /dev/null
@@ -1,79 +0,0 @@
-
-<h1>Burger House Bakú: La mejor guía para las mejores hamburguesas de la ciudad</h1>
-<p>Si usted está buscando un lugar para disfrutar de una deliciosa hamburguesa en Bakú, usted debe definitivamente echa un vistazo a Burger House Bakú. Este restaurante ofrece una variedad de hamburguesas, acompañamientos y bebidas que satisfarán sus antojos y lo harán feliz. En este artículo, te contaremos todo lo que necesitas saber sobre Burger House Bakú, incluyendo qué es, por qué debes visitarlo, qué sirve, dónde se encuentra, cuándo está abierto y qué piensan otros clientes de él. ¡Sigue leyendo para saber más! </p>
-<h2>Introducción</h2>
-<h3>¿Qué es Burger House Bakú? </h3>
-<p>Burger House Bakú es un restaurante especializado en hamburguesas. Fue fundada en 2018 por un grupo de amigos que querían compartir su pasión por las hamburguesas con la gente de Bakú. Utilizan ingredientes frescos, salsas caseras y carne de calidad para crear sus hamburguesas, que se cocinan por encargo y se sirven con una sonrisa. Burger House Bakú tiene como objetivo proporcionar un ambiente agradable y acogedor donde los clientes pueden relajarse y disfrutar de su comida. </p>
-<h2>baku burger house</h2><br /><p><b><b>Download</b> &#9658;&#9658;&#9658;&#9658;&#9658; <a href="https://bltlly.com/2v6Mzw">https://bltlly.com/2v6Mzw</a></b></p><br /><br />
-<h3>¿Por qué visitar Burger House Bakú? </h3>
-<p>Hay muchas razones por las que deberías visitar Burger House Bakú. Aquí están algunas de ellas:</p>
-<ul>
-<li>Podrás degustar algunas de las mejores hamburguesas de la ciudad, elaboradas con ingredientes frescos y de calidad. </li>
-<li>Usted tendrá una amplia gama de opciones para elegir, incluyendo hamburguesas clásicas, hamburguesas con queso, hamburguesas de tocino, hamburguesas vegetarianas y más. </li>
-<li>También podrás disfrutar de algunos deliciosos platos, como papas fritas, aros de cebolla, ensalada y más. </li>
-<li>Podrás saciar tu sed con algunas bebidas refrescantes, como refrescos, cerveza, batidos y más. </li>
-<li>Experimentará un ambiente agradable y acogedor, con personal atento y música agradable. </li>
-<li>Obtendrá una buena relación calidad-precio, ya que los precios son razonables y las porciones generosas. </li>
-</ul>
-<h2>El menú</h2>
-<h3>Las hamburguesas</h3>
-
-<h4>Hamburguesa clásica</h4>
-<p>Esta es la hamburguesa más simple y básica del menú. Consiste en una hamburguesa de ternera, lechuga, tomate, cebolla, pepinillos, ketchup, mostaza y mayonesa en un pan de sésamo. Es perfecto para aquellos que quieren una hamburguesa clásica y sencilla que sea satisfactoria y sabrosa. </p>
-<h4>Hamburguesa de queso</h4>
-<p>Esta es una hamburguesa clásica con un toque extra de queso. Consiste en una hamburguesa de ternera, queso, lechuga, tomate, cebolla, encurtidos, ketchup, mostaza y mayonesa en un bollo de sésamo. Es perfecto para aquellos que aman el queso y quieren una hamburguesa más sabrosa. </p>
-<h4>Hamburguesa de tocino</h4>
-<p>Esta es una hamburguesa clásica con un toque extra de tocino. Consiste en una hamburguesa de ternera, tocino, queso, lechuga, tomate, cebolla, encurtidos, ketchup, mostaza y mayonesa en un bollo de sésamo. Es perfecto para aquellos que aman el tocino y quieren una hamburguesa más crujiente y ahumado. </p>
-<h4>Hamburguesa vegetariana</h4>
-<p>Esta es una hamburguesa para aquellos que prefieren una opción vegetariana. Consiste en una hamburguesa vegetariana, lechuga, tomate, cebolla, encurtidos, ketchup, mostaza y mayonesa en un bollo de sésamo. Es perfecto para aquellos que quieren una hamburguesa sana y libre de carne que sigue siendo deliciosa y satisfactoria. </p>
-<h3>Los lados</h3>
-<p>Ninguna hamburguesa está completa sin algunos lados para ir junto con ella. Burger House Bakú ofrece algunos lados sabrosos y crujientes que complementan sus hamburguesas. Estos son algunos de sus lados más populares:</p>
-<p></p>
-<h4>Fries</h4>
-<p>Estos son los platos clásicos y más populares para hamburguesas. Están hechos de papas frescas que se cortan en tiras finas y se fríen hasta que estén doradas y crujientes. Se sazona con sal y se sirve con ketchup o mayonesa. Son perfectos para aquellos que quieren un lado simple y crujiente que vaya bien con cualquier hamburguesa. </p>
-<h4>Anillos de cebolla</h4>
-
-<h4>Ensalada</h4>
-<p>Este es un acompañamiento para aquellos que quieren una opción más ligera y saludable. Está hecho de lechuga fresca, tomate, pepino, zanahoria y cebolla que se mezclan con aderezo. Se sirve con crutones o queso en la parte superior. Es perfecto para aquellos que quieren un lado refrescante y nutritivo que equilibre su hamburguesa. </p>
-<h3>Las bebidas</h3>
-<p>Para lavar su hamburguesa y los lados, necesitará algunas bebidas para saciar su sed. Burger House Bakú ofrece algunas bebidas refrescantes y deliciosas que se adaptan a diferentes gustos y preferencias. Aquí están algunas de sus bebidas más populares:</p>
-<h4>Soda</h4>
-<p>Esta es la bebida clásica y más popular para las hamburguesas. Es una bebida carbonatada que viene en diferentes sabores, como cola, limón, naranja y más. Se sirve fría con cubitos de hielo. Es perfecto para aquellos que quieren una bebida dulce y gaseosa que vaya bien con cualquier hamburguesa. </p>
-<h4>Cerveza</h4>
-<p>Esta es otra bebida popular para hamburguesas. Es una bebida alcohólica que viene en diferentes tipos, como lager, ale, stout y más. Se sirve frío con o sin espuma. Es perfecto para aquellos que quieren una bebida amarga y refrescante que realza el sabor de su hamburguesa. </p>
-<h4>Batido de leche</h4>
-<p>Esta es una bebida para aquellos que quieren un tratamiento cremoso e indulgente. Es una bebida mezclada que viene en diferentes sabores, como chocolate, vainilla, fresa y más. Se sirve frío con crema batida y una cereza en la parte superior. Es perfecto para aquellos que quieren una bebida rica y suave que satisfaga su gusto por los dulces. </p>
-<h2>La ubicación y las horas</h2>
-<h3>¿Dónde está Burger House Bakú? </h3>
-<p>Burger House Bakú se encuentra en el corazón de la ciudad, cerca de la Plaza de la Fuente. La dirección es 28 Nizami Street, Bakú 1000. Se puede llegar fácilmente en transporte público o en coche. Hay un amplio aparcamiento cerca. </p>
-<h3>¿Cuándo está abierto Burger House Bakú? </h3>
-
-<h2>Los comentarios y valoraciones</h2>
-<h3>¿Qué dicen los clientes sobre Burger House Baku? </h3>
-<p>Burger House Bakú ha recibido muchas críticas positivas y valoraciones de clientes que han probado su comida. Estos son algunos de los comentarios que han dejado en varias plataformas:</p>
-<ul>
-<li>"¡Las mejores hamburguesas de la ciudad! ¡Frescas, jugosas, sabrosas y grandes! ¡Las papas fritas también son increíbles! ¡Muy recomendable!" - Ali en Google Reviews</li>
-<li>"Me encanta este lugar! Las hamburguesas son tan buenas y el personal es tan amable! El ambiente es acogedor y relajante! Siempre vengo aquí con mis amigos!" - Leyla en Facebook</li>
-<li>"Burger House Bakú es mi lugar favorito de hamburguesas en Bakú! Las hamburguesas se cocinan a la perfección y los lados son deliciosos! Los precios son razonables y las porciones son generosas! No puedo tener suficiente de ella!" - Samir en TripAdvisor</li>
-</ul>
-<h3>¿Cómo se compara Burger House Bakú con otros lugares de hamburguesas en Bakú? </ <p>Burger House Bakú es uno de los mejores lugares de hamburguesas en Bakú, según muchos clientes y críticos. Tiene una alta calificación de 4.8 de 5 estrellas en Google Reviews, 4.9 de 5 estrellas en Facebook y 4.5 de 5 estrellas en TripAdvisor  . También tiene un Certificado de Excelencia de TripAdvisor, lo que significa que recibe constantemente excelentes críticas de los viajeros. Burger House Bakú se destaca de otros lugares de hamburguesas en Bakú debido a su calidad, variedad, servicio y valor. Ofrece hamburguesas frescas y sabrosas que se adaptan a diferentes gustos y preferencias, así como deliciosas guarniciones y bebidas que las complementan. También ofrece un ambiente agradable y acogedor, con personal atento y música agradable. También ofrece precios razonables y porciones generosas que hacen que los clientes se sientan satisfechos y felices. </p>
-<h2>Conclusión</h2>
-<h3>Resumen de los puntos principales</h3>
-
-<h3>Llamada a la acción</h3>
-<p>Si usted está buscando un lugar para disfrutar de una deliciosa hamburguesa en Bakú, usted debe definitivamente echa un vistazo a Burger House Bakú. Usted no se arrepentirá! Puede visitar su sitio web para ver su menú, ordenar en línea o hacer una reserva. También puede seguirlos en las redes sociales para obtener las últimas actualizaciones y promociones. ¡No pierdas esta oportunidad de probar algunas de las mejores hamburguesas de la ciudad! ¡Visita Burger House Bakú hoy! </p>
-<h2>Preguntas frecuentes</h2>
-<ul>
-<li>Q: ¿Cómo puedo contactar con Burger House Baku? </li>
-<li>A: Puede ponerse en contacto con Burger House Bakú por teléfono al +994 12 555 55 55 o por correo electrónico a info@burgerhousebaku.com. </li>
-<li>Q: ¿Burger House Bakú ofrece entrega o comida para llevar? </li>
-<li>A: Sí, Burger House Bakú ofrece opciones de entrega y comida para llevar. Usted puede ordenar en línea a través de su sitio web o por teléfono, y tener su comida entregada a su casa u oficina. También puede recoger su comida de su restaurante. </li>
-<li>Q: ¿Burger House Bakú tiene ofertas especiales o descuentos? </li>
-<li>A: Sí, Burger House Bakú tiene algunas ofertas especiales y descuentos para sus clientes. Por ejemplo, puede obtener una bebida gratis con cualquier pedido de hamburguesas los lunes, o obtener un descuento del 10% en su factura si muestra su identificación de estudiante los martes. También puede unirse a su programa de lealtad y obtener puntos por cada compra que puede canjear por alimentos o regalos gratis. </li>
-<li>Q: ¿Burger House Baku abastece para eventos o fiestas? </li>
-<li>A: Sí, Burger House Bakú atiende a eventos o fiestas de cualquier tamaño y ocasión. Puedes elegir entre su menú de catering o personalizar tu propio menú según tus necesidades y preferencias. También puede reservar su restaurante para eventos privados o fiestas. </li>
-<li>P: ¿Burger House Bakú tiene opciones vegetarianas o veganas? </li>
-
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/BestteaLib/README/README.md b/spaces/BestteaLib/README/README.md
deleted file mode 100644
index 3194fcbd06e56d0e8126c9a0abdd2db4d932fe03..0000000000000000000000000000000000000000
--- a/spaces/BestteaLib/README/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: README
-emoji: 🏢
-colorFrom: purple
-colorTo: purple
-sdk: static
-pinned: false
----
-
-Edit this `README.md` markdown file to author your organization card.
diff --git a/spaces/BetterAPI/BetterChat_new/src/lib/utils/share.ts b/spaces/BetterAPI/BetterChat_new/src/lib/utils/share.ts
deleted file mode 100644
index 4587669a10164aa7c961429fbddec9cf438c0eca..0000000000000000000000000000000000000000
--- a/spaces/BetterAPI/BetterChat_new/src/lib/utils/share.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-export function share(url: string, title: string) {
-	if (navigator.share) {
-		navigator.share({ url, title });
-	} else {
-		prompt("Copy this public url to share:", url);
-	}
-}
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/packaging/tags.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/packaging/tags.py
deleted file mode 100644
index 9a3d25a71c75c975291cf987001ecd6882d6417d..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/packaging/tags.py
+++ /dev/null
@@ -1,487 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-import logging
-import platform
-import sys
-import sysconfig
-from importlib.machinery import EXTENSION_SUFFIXES
-from typing import (
-    Dict,
-    FrozenSet,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Union,
-    cast,
-)
-
-from . import _manylinux, _musllinux
-
-logger = logging.getLogger(__name__)
-
-PythonVersion = Sequence[int]
-MacVersion = Tuple[int, int]
-
-INTERPRETER_SHORT_NAMES: Dict[str, str] = {
-    "python": "py",  # Generic.
-    "cpython": "cp",
-    "pypy": "pp",
-    "ironpython": "ip",
-    "jython": "jy",
-}
-
-
-_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32
-
-
-class Tag:
-    """
-    A representation of the tag triple for a wheel.
-
-    Instances are considered immutable and thus are hashable. Equality checking
-    is also supported.
-    """
-
-    __slots__ = ["_interpreter", "_abi", "_platform", "_hash"]
-
-    def __init__(self, interpreter: str, abi: str, platform: str) -> None:
-        self._interpreter = interpreter.lower()
-        self._abi = abi.lower()
-        self._platform = platform.lower()
-        # The __hash__ of every single element in a Set[Tag] will be evaluated each time
-        # that a set calls its `.disjoint()` method, which may be called hundreds of
-        # times when scanning a page of links for packages with tags matching that
-        # Set[Tag]. Pre-computing the value here produces significant speedups for
-        # downstream consumers.
-        self._hash = hash((self._interpreter, self._abi, self._platform))
-
-    @property
-    def interpreter(self) -> str:
-        return self._interpreter
-
-    @property
-    def abi(self) -> str:
-        return self._abi
-
-    @property
-    def platform(self) -> str:
-        return self._platform
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Tag):
-            return NotImplemented
-
-        return (
-            (self._hash == other._hash)  # Short-circuit ASAP for perf reasons.
-            and (self._platform == other._platform)
-            and (self._abi == other._abi)
-            and (self._interpreter == other._interpreter)
-        )
-
-    def __hash__(self) -> int:
-        return self._hash
-
-    def __str__(self) -> str:
-        return f"{self._interpreter}-{self._abi}-{self._platform}"
-
-    def __repr__(self) -> str:
-        return f"<{self} @ {id(self)}>"
-
-
-def parse_tag(tag: str) -> FrozenSet[Tag]:
-    """
-    Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances.
-
-    Returning a set is required due to the possibility that the tag is a
-    compressed tag set.
-    """
-    tags = set()
-    interpreters, abis, platforms = tag.split("-")
-    for interpreter in interpreters.split("."):
-        for abi in abis.split("."):
-            for platform_ in platforms.split("."):
-                tags.add(Tag(interpreter, abi, platform_))
-    return frozenset(tags)
-
-
-def _get_config_var(name: str, warn: bool = False) -> Union[int, str, None]:
-    value = sysconfig.get_config_var(name)
-    if value is None and warn:
-        logger.debug(
-            "Config variable '%s' is unset, Python ABI tag may be incorrect", name
-        )
-    return value
-
-
-def _normalize_string(string: str) -> str:
-    return string.replace(".", "_").replace("-", "_")
-
-
-def _abi3_applies(python_version: PythonVersion) -> bool:
-    """
-    Determine if the Python version supports abi3.
-
-    PEP 384 was first implemented in Python 3.2.
-    """
-    return len(python_version) > 1 and tuple(python_version) >= (3, 2)
-
-
-def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> List[str]:
-    py_version = tuple(py_version)  # To allow for version comparison.
-    abis = []
-    version = _version_nodot(py_version[:2])
-    debug = pymalloc = ucs4 = ""
-    with_debug = _get_config_var("Py_DEBUG", warn)
-    has_refcount = hasattr(sys, "gettotalrefcount")
-    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
-    # extension modules is the best option.
-    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692
-    has_ext = "_d.pyd" in EXTENSION_SUFFIXES
-    if with_debug or (with_debug is None and (has_refcount or has_ext)):
-        debug = "d"
-    if py_version < (3, 8):
-        with_pymalloc = _get_config_var("WITH_PYMALLOC", warn)
-        if with_pymalloc or with_pymalloc is None:
-            pymalloc = "m"
-        if py_version < (3, 3):
-            unicode_size = _get_config_var("Py_UNICODE_SIZE", warn)
-            if unicode_size == 4 or (
-                unicode_size is None and sys.maxunicode == 0x10FFFF
-            ):
-                ucs4 = "u"
-    elif debug:
-        # Debug builds can also load "normal" extension modules.
-        # We can also assume no UCS-4 or pymalloc requirement.
-        abis.append(f"cp{version}")
-    abis.insert(
-        0,
-        "cp{version}{debug}{pymalloc}{ucs4}".format(
-            version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4
-        ),
-    )
-    return abis
-
-
-def cpython_tags(
-    python_version: Optional[PythonVersion] = None,
-    abis: Optional[Iterable[str]] = None,
-    platforms: Optional[Iterable[str]] = None,
-    *,
-    warn: bool = False,
-) -> Iterator[Tag]:
-    """
-    Yields the tags for a CPython interpreter.
-
-    The tags consist of:
-    - cp<python_version>-<abi>-<platform>
-    - cp<python_version>-abi3-<platform>
-    - cp<python_version>-none-<platform>
-    - cp<less than python_version>-abi3-<platform>  # Older Python versions down to 3.2.
-
-    If python_version only specifies a major version then user-provided ABIs and
-    the 'none' ABItag will be used.
-
-    If 'abi3' or 'none' are specified in 'abis' then they will be yielded at
-    their normal position and not at the beginning.
-    """
-    if not python_version:
-        python_version = sys.version_info[:2]
-
-    interpreter = f"cp{_version_nodot(python_version[:2])}"
-
-    if abis is None:
-        if len(python_version) > 1:
-            abis = _cpython_abis(python_version, warn)
-        else:
-            abis = []
-    abis = list(abis)
-    # 'abi3' and 'none' are explicitly handled later.
-    for explicit_abi in ("abi3", "none"):
-        try:
-            abis.remove(explicit_abi)
-        except ValueError:
-            pass
-
-    platforms = list(platforms or platform_tags())
-    for abi in abis:
-        for platform_ in platforms:
-            yield Tag(interpreter, abi, platform_)
-    if _abi3_applies(python_version):
-        yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms)
-    yield from (Tag(interpreter, "none", platform_) for platform_ in platforms)
-
-    if _abi3_applies(python_version):
-        for minor_version in range(python_version[1] - 1, 1, -1):
-            for platform_ in platforms:
-                interpreter = "cp{version}".format(
-                    version=_version_nodot((python_version[0], minor_version))
-                )
-                yield Tag(interpreter, "abi3", platform_)
-
-
-def _generic_abi() -> Iterator[str]:
-    abi = sysconfig.get_config_var("SOABI")
-    if abi:
-        yield _normalize_string(abi)
-
-
-def generic_tags(
-    interpreter: Optional[str] = None,
-    abis: Optional[Iterable[str]] = None,
-    platforms: Optional[Iterable[str]] = None,
-    *,
-    warn: bool = False,
-) -> Iterator[Tag]:
-    """
-    Yields the tags for a generic interpreter.
-
-    The tags consist of:
-    - <interpreter>-<abi>-<platform>
-
-    The "none" ABI will be added if it was not explicitly provided.
-    """
-    if not interpreter:
-        interp_name = interpreter_name()
-        interp_version = interpreter_version(warn=warn)
-        interpreter = "".join([interp_name, interp_version])
-    if abis is None:
-        abis = _generic_abi()
-    platforms = list(platforms or platform_tags())
-    abis = list(abis)
-    if "none" not in abis:
-        abis.append("none")
-    for abi in abis:
-        for platform_ in platforms:
-            yield Tag(interpreter, abi, platform_)
-
-
-def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]:
-    """
-    Yields Python versions in descending order.
-
-    After the latest version, the major-only version will be yielded, and then
-    all previous versions of that major version.
-    """
-    if len(py_version) > 1:
-        yield f"py{_version_nodot(py_version[:2])}"
-    yield f"py{py_version[0]}"
-    if len(py_version) > 1:
-        for minor in range(py_version[1] - 1, -1, -1):
-            yield f"py{_version_nodot((py_version[0], minor))}"
-
-
-def compatible_tags(
-    python_version: Optional[PythonVersion] = None,
-    interpreter: Optional[str] = None,
-    platforms: Optional[Iterable[str]] = None,
-) -> Iterator[Tag]:
-    """
-    Yields the sequence of tags that are compatible with a specific version of Python.
-
-    The tags consist of:
-    - py*-none-<platform>
-    - <interpreter>-none-any  # ... if `interpreter` is provided.
-    - py*-none-any
-    """
-    if not python_version:
-        python_version = sys.version_info[:2]
-    platforms = list(platforms or platform_tags())
-    for version in _py_interpreter_range(python_version):
-        for platform_ in platforms:
-            yield Tag(version, "none", platform_)
-    if interpreter:
-        yield Tag(interpreter, "none", "any")
-    for version in _py_interpreter_range(python_version):
-        yield Tag(version, "none", "any")
-
-
-def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str:
-    if not is_32bit:
-        return arch
-
-    if arch.startswith("ppc"):
-        return "ppc"
-
-    return "i386"
-
-
-def _mac_binary_formats(version: MacVersion, cpu_arch: str) -> List[str]:
-    formats = [cpu_arch]
-    if cpu_arch == "x86_64":
-        if version < (10, 4):
-            return []
-        formats.extend(["intel", "fat64", "fat32"])
-
-    elif cpu_arch == "i386":
-        if version < (10, 4):
-            return []
-        formats.extend(["intel", "fat32", "fat"])
-
-    elif cpu_arch == "ppc64":
-        # TODO: Need to care about 32-bit PPC for ppc64 through 10.2?
-        if version > (10, 5) or version < (10, 4):
-            return []
-        formats.append("fat64")
-
-    elif cpu_arch == "ppc":
-        if version > (10, 6):
-            return []
-        formats.extend(["fat32", "fat"])
-
-    if cpu_arch in {"arm64", "x86_64"}:
-        formats.append("universal2")
-
-    if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}:
-        formats.append("universal")
-
-    return formats
-
-
-def mac_platforms(
-    version: Optional[MacVersion] = None, arch: Optional[str] = None
-) -> Iterator[str]:
-    """
-    Yields the platform tags for a macOS system.
-
-    The `version` parameter is a two-item tuple specifying the macOS version to
-    generate platform tags for. The `arch` parameter is the CPU architecture to
-    generate platform tags for. Both parameters default to the appropriate value
-    for the current system.
-    """
-    version_str, _, cpu_arch = platform.mac_ver()
-    if version is None:
-        version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2])))
-    else:
-        version = version
-    if arch is None:
-        arch = _mac_arch(cpu_arch)
-    else:
-        arch = arch
-
-    if (10, 0) <= version and version < (11, 0):
-        # Prior to Mac OS 11, each yearly release of Mac OS bumped the
-        # "minor" version number.  The major version was always 10.
-        for minor_version in range(version[1], -1, -1):
-            compat_version = 10, minor_version
-            binary_formats = _mac_binary_formats(compat_version, arch)
-            for binary_format in binary_formats:
-                yield "macosx_{major}_{minor}_{binary_format}".format(
-                    major=10, minor=minor_version, binary_format=binary_format
-                )
-
-    if version >= (11, 0):
-        # Starting with Mac OS 11, each yearly release bumps the major version
-        # number.   The minor versions are now the midyear updates.
-        for major_version in range(version[0], 10, -1):
-            compat_version = major_version, 0
-            binary_formats = _mac_binary_formats(compat_version, arch)
-            for binary_format in binary_formats:
-                yield "macosx_{major}_{minor}_{binary_format}".format(
-                    major=major_version, minor=0, binary_format=binary_format
-                )
-
-    if version >= (11, 0):
-        # Mac OS 11 on x86_64 is compatible with binaries from previous releases.
-        # Arm64 support was introduced in 11.0, so no Arm binaries from previous
-        # releases exist.
-        #
-        # However, the "universal2" binary format can have a
-        # macOS version earlier than 11.0 when the x86_64 part of the binary supports
-        # that version of macOS.
-        if arch == "x86_64":
-            for minor_version in range(16, 3, -1):
-                compat_version = 10, minor_version
-                binary_formats = _mac_binary_formats(compat_version, arch)
-                for binary_format in binary_formats:
-                    yield "macosx_{major}_{minor}_{binary_format}".format(
-                        major=compat_version[0],
-                        minor=compat_version[1],
-                        binary_format=binary_format,
-                    )
-        else:
-            for minor_version in range(16, 3, -1):
-                compat_version = 10, minor_version
-                binary_format = "universal2"
-                yield "macosx_{major}_{minor}_{binary_format}".format(
-                    major=compat_version[0],
-                    minor=compat_version[1],
-                    binary_format=binary_format,
-                )
-
-
-def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]:
-    linux = _normalize_string(sysconfig.get_platform())
-    if is_32bit:
-        if linux == "linux_x86_64":
-            linux = "linux_i686"
-        elif linux == "linux_aarch64":
-            linux = "linux_armv7l"
-    _, arch = linux.split("_", 1)
-    yield from _manylinux.platform_tags(linux, arch)
-    yield from _musllinux.platform_tags(arch)
-    yield linux
-
-
-def _generic_platforms() -> Iterator[str]:
-    yield _normalize_string(sysconfig.get_platform())
-
-
-def platform_tags() -> Iterator[str]:
-    """
-    Provides the platform tags for this installation.
-    """
-    if platform.system() == "Darwin":
-        return mac_platforms()
-    elif platform.system() == "Linux":
-        return _linux_platforms()
-    else:
-        return _generic_platforms()
-
-
-def interpreter_name() -> str:
-    """
-    Returns the name of the running interpreter.
-    """
-    name = sys.implementation.name
-    return INTERPRETER_SHORT_NAMES.get(name) or name
-
-
-def interpreter_version(*, warn: bool = False) -> str:
-    """
-    Returns the version of the running interpreter.
-    """
-    version = _get_config_var("py_version_nodot", warn=warn)
-    if version:
-        version = str(version)
-    else:
-        version = _version_nodot(sys.version_info[:2])
-    return version
-
-
-def _version_nodot(version: PythonVersion) -> str:
-    return "".join(map(str, version))
-
-
-def sys_tags(*, warn: bool = False) -> Iterator[Tag]:
-    """
-    Returns the sequence of tag triples for the running interpreter.
-
-    The order of the sequence corresponds to priority order for the
-    interpreter, from most to least important.
-    """
-
-    interp_name = interpreter_name()
-    if interp_name == "cp":
-        yield from cpython_tags(warn=warn)
-    else:
-        yield from generic_tags()
-
-    if interp_name == "pp":
-        yield from compatible_tags(interpreter="pp3")
-    else:
-        yield from compatible_tags()
diff --git a/spaces/CVH-vn1210/make_hair/minigpt4/datasets/datasets/__init__.py b/spaces/CVH-vn1210/make_hair/minigpt4/datasets/datasets/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/demo/demo.py b/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/demo/demo.py
deleted file mode 100644
index cf82e3faf659027792aa597432eafa48fb16385b..0000000000000000000000000000000000000000
--- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/demo/demo.py
+++ /dev/null
@@ -1,159 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import argparse
-import glob
-import multiprocessing as mp
-import os
-import time
-import cv2
-import tqdm
-
-from detectron2.config import get_cfg
-from detectron2.data.detection_utils import read_image
-from detectron2.utils.logger import setup_logger
-
-from predictor import VisualizationDemo
-
-# constants
-WINDOW_NAME = "COCO detections"
-
-
-def setup_cfg(args):
-    # load config from file and command-line arguments
-    cfg = get_cfg()
-    cfg.merge_from_file(args.config_file)
-    cfg.merge_from_list(args.opts)
-    # Set score_threshold for builtin models
-    cfg.MODEL.RETINANET.SCORE_THRESH_TEST = args.confidence_threshold
-    cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = args.confidence_threshold
-    cfg.MODEL.PANOPTIC_FPN.COMBINE.INSTANCES_CONFIDENCE_THRESH = args.confidence_threshold
-    cfg.freeze()
-    return cfg
-
-
-def get_parser():
-    parser = argparse.ArgumentParser(description="Detectron2 demo for builtin models")
-    parser.add_argument(
-        "--config-file",
-        default="configs/quick_schedules/mask_rcnn_R_50_FPN_inference_acc_test.yaml",
-        metavar="FILE",
-        help="path to config file",
-    )
-    parser.add_argument("--webcam", action="store_true", help="Take inputs from webcam.")
-    parser.add_argument("--video-input", help="Path to video file.")
-    parser.add_argument(
-        "--input",
-        nargs="+",
-        help="A list of space separated input images; "
-        "or a single glob pattern such as 'directory/*.jpg'",
-    )
-    parser.add_argument(
-        "--output",
-        help="A file or directory to save output visualizations. "
-        "If not given, will show output in an OpenCV window.",
-    )
-
-    parser.add_argument(
-        "--confidence-threshold",
-        type=float,
-        default=0.5,
-        help="Minimum score for instance predictions to be shown",
-    )
-    parser.add_argument(
-        "--opts",
-        help="Modify config options using the command-line 'KEY VALUE' pairs",
-        default=[],
-        nargs=argparse.REMAINDER,
-    )
-    return parser
-
-
-if __name__ == "__main__":
-    mp.set_start_method("spawn", force=True)
-    args = get_parser().parse_args()
-    setup_logger(name="fvcore")
-    logger = setup_logger()
-    logger.info("Arguments: " + str(args))
-
-    cfg = setup_cfg(args)
-
-    demo = VisualizationDemo(cfg)
-
-    if args.input:
-        if len(args.input) == 1:
-            args.input = glob.glob(os.path.expanduser(args.input[0]))
-            assert args.input, "The input path(s) was not found"
-        for path in tqdm.tqdm(args.input, disable=not args.output):
-            # use PIL, to be consistent with evaluation
-            img = read_image(path, format="BGR")
-            start_time = time.time()
-            predictions, visualized_output = demo.run_on_image(img)
-            logger.info(
-                "{}: {} in {:.2f}s".format(
-                    path,
-                    "detected {} instances".format(len(predictions["instances"]))
-                    if "instances" in predictions
-                    else "finished",
-                    time.time() - start_time,
-                )
-            )
-
-            if args.output:
-                if os.path.isdir(args.output):
-                    assert os.path.isdir(args.output), args.output
-                    out_filename = os.path.join(args.output, os.path.basename(path))
-                else:
-                    assert len(args.input) == 1, "Please specify a directory with args.output"
-                    out_filename = args.output
-                visualized_output.save(out_filename)
-            else:
-                cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_NORMAL)
-                cv2.imshow(WINDOW_NAME, visualized_output.get_image()[:, :, ::-1])
-                if cv2.waitKey(0) == 27:
-                    break  # esc to quit
-    elif args.webcam:
-        assert args.input is None, "Cannot have both --input and --webcam!"
-        cam = cv2.VideoCapture(0)
-        for vis in tqdm.tqdm(demo.run_on_video(cam)):
-            cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_NORMAL)
-            cv2.imshow(WINDOW_NAME, vis)
-            if cv2.waitKey(1) == 27:
-                break  # esc to quit
-        cv2.destroyAllWindows()
-    elif args.video_input:
-        video = cv2.VideoCapture(args.video_input)
-        width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
-        height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        frames_per_second = video.get(cv2.CAP_PROP_FPS)
-        num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
-        basename = os.path.basename(args.video_input)
-
-        if args.output:
-            if os.path.isdir(args.output):
-                output_fname = os.path.join(args.output, basename)
-                output_fname = os.path.splitext(output_fname)[0] + ".mkv"
-            else:
-                output_fname = args.output
-            assert not os.path.isfile(output_fname), output_fname
-            output_file = cv2.VideoWriter(
-                filename=output_fname,
-                # some installation of opencv may not support x264 (due to its license),
-                # you can try other format (e.g. MPEG)
-                fourcc=cv2.VideoWriter_fourcc(*"x264"),
-                fps=float(frames_per_second),
-                frameSize=(width, height),
-                isColor=True,
-            )
-        assert os.path.isfile(args.video_input)
-        for vis_frame in tqdm.tqdm(demo.run_on_video(video), total=num_frames):
-            if args.output:
-                output_file.write(vis_frame)
-            else:
-                cv2.namedWindow(basename, cv2.WINDOW_NORMAL)
-                cv2.imshow(basename, vis_frame)
-                if cv2.waitKey(1) == 27:
-                    break  # esc to quit
-        video.release()
-        if args.output:
-            output_file.release()
-        else:
-            cv2.destroyAllWindows()
diff --git a/spaces/CVPR/LIVE/thrust/CONTRIBUTING.md b/spaces/CVPR/LIVE/thrust/CONTRIBUTING.md
deleted file mode 100644
index 5ab75fa6650687c849caf75deb2f926cd628f239..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/CONTRIBUTING.md
+++ /dev/null
@@ -1,490 +0,0 @@
-# Table of Contents
-
-1. [Contributing to Thrust](#contributing-to-thrust)
-1. [CMake Options](#cmake-options)
-1. [Development Model](#development-model)
-
-# Contributing to Thrust
-
-Thrust uses Github to manage all open-source development, including bug
-tracking, pull requests, and design discussions. This document details how to get
-started as a Thrust contributor.
-
-An overview of this process is:
-
-1. [Clone the Thrust repository](#clone-the-thrust-repository)
-1. [Setup a fork of Thrust](#setup-a-fork-of-thrust)
-1. [Setup your environment](#setup-your-environment)
-1. [Create a development branch](#create-a-development-branch)
-1. [Local development loop](#local-development-loop)
-1. [Push development branch to your fork](#push-development-branch-to-your-fork)
-1. [Create pull request](#create-pull-request)
-1. [Address feedback and update pull request](#address-feedback-and-update-pull-request)
-1. [When your PR is approved...](#when-your-pr-is-approved)
-
-## Clone the Thrust Repository
-
-To get started, clone the main repository to your local computer. Thrust should
-be cloned recursively to setup the CUB submodule (required for `CUDA`
-acceleration).
-
-```
-git clone --recursive https://github.com/thrust/thrust.git
-cd thrust
-```
-
-## Setup a Fork of Thrust
-
-You'll need a fork of Thrust on Github to create a pull request. To setup your
-fork:
-
-1. Create a Github account (if needed)
-2. Go to [the Thrust Github page](https://github.com/thrust/thrust)
-3. Click "Fork" and follow any prompts that appear.
-
-Once your fork is created, setup a new remote repo in your local Thrust clone:
-
-```
-git remote add github-fork git@github.com:<GITHUB_USERNAME>/thrust.git
-```
-
-If you need to modify CUB, too, go to
-[the CUB Github page](https://github.com/thrust/cub) and repeat this process.
-Create CUB's `github-fork` remote in the `thrust/dependencies/cub` submodule.
-
-## Setup Your Environment
-
-### Git Environment
-
-If you haven't already, this is a good time to tell git who you are. This
-information is used to fill out authorship information on your git commits.
-
-```
-git config --global user.name "John Doe"
-git config --global user.email johndoe@example.com
-```
-
-### Configure CMake builds
-
-Thrust uses [CMake](https://www.cmake.org) for its developer build system. To
-configure, build, and test your checkout of Thrust:
-
-```
-# Create build directory:
-mkdir build
-cd build
-
-# Configure -- use one of the following:
-cmake ..   # Command line interface.
-ccmake ..  # ncurses GUI (Linux only)
-cmake-gui  # Graphical UI, set source/build directories in the app
-
-# Build:
-cmake --build . -j <num jobs>   # invokes make (or ninja, etc)
-
-# Run tests and examples:
-ctest
-```
-
-See [CMake Options](#cmake-options) for details on customizing the build.
-
-## Create a Development Branch
-
-All work should be done in a development branch (also called a "topic branch")
-and not directly in the `master` branch. This makes it easier to manage multiple
-in-progress patches at once, and provides a descriptive label for your patch
-as it passes through the review system.
-
-To create a new branch based on the current `master`:
-
-```
-# Checkout local master branch:
-cd /path/to/thrust/sources
-git checkout master
-
-# Sync local master branch with github:
-git pull
-
-# Create a new branch named `my_descriptive_branch_name` based on master:
-git checkout -b my_descriptive_branch_name
-
-# Verify that the branch has been created and is currently checked out:
-git branch
-```
-
-Thrust branch names should follow a particular pattern:
-
-- For new features, name the branch `feature/<name>`
-- For bugfixes associated with a github issue, use `bug/github/<bug-description>-<bug-id>`
-  - Internal nvidia and gitlab bugs should use `nvidia` or `gitlab` in place of
-    `github`.
-
-If you plan to work on CUB as part of your patch, repeat this process in the
-`thrust/dependencies/cub` submodule.
-
-## Local Development Loop
-
-### Edit, Build, Test, Repeat
-
-Once the topic branch is created, you're all set to start working on Thrust
-code. Make some changes, then build and test them:
-
-```
-# Implement changes:
-cd /path/to/thrust/sources
-emacs thrust/some_file.h # or whatever editor you prefer
-
-# Create / update a unit test for your changes:
-emacs testing/some_test.cu
-
-# Check that everything builds and tests pass:
-cd /path/to/thrust/build/directory
-cmake --build . -j <num jobs>
-ctest
-```
-
-### Creating a Commit
-
-Once you're satisfied with your patch, commit your changes:
-
-#### Thrust-only Changes
-
-```
-# Manually add changed files and create a commit:
-cd /path/to/thrust
-git add thrust/some_file.h
-git add testing/some_test.cu
-git commit
-
-# Or, if possible, use git-gui to review your changes while building your patch:
-git gui
-```
-
-#### Thrust and CUB Changes
-
-```
-# Create CUB patch first:
-cd /path/to/thrust/dependencies/cub
-# Manually add changed files and create a commit:
-git add cub/some_file.cuh
-git commit
-
-# Create Thrust patch, including submodule update:
-cd /path/to/thrust/
-git add dependencies/cub # Updates submodule info
-git add thrust/some_file.h
-git add testing/some_test.cu
-git commit
-
-# Or, if possible, use git-gui to review your changes while building your patch:
-cd /path/to/thrust/dependencies/cub
-git gui
-cd /path/to/thrust
-git gui # Include dependencies/cub as part of your commit
-
-```
-
-#### Writing a Commit Message
-
-Your commit message will communicate the purpose and rationale behind your
-patch to other developers, and will be used to populate the initial description
-of your Github pull request.
-
-When writing a commit message, the following standard format should be used,
-since tools in the git ecosystem are designed to parse this correctly:
-
-```
-First line of commit message is a short summary (<80 char)
-<Second line left blank>
-Detailed description of change begins on third line. This portion can
-span multiple lines, try to manually wrap them at something reasonable.
-
-Blank lines can be used to separate multiple paragraphs in the description.
-
-If your patch is associated with another pull request or issue in the main
-Thrust repository, you should reference it with a `#` symbol, e.g.
-#1023 for issue 1023.
-
-For issues / pull requests in a different github repo, reference them using
-the full syntax, e.g. thrust/cub#4 for issue 4 in the thrust/cub repo.
-
-Markdown is recommended for formatting more detailed messages, as these will
-be nicely rendered on Github, etc.
-```
-
-## Push Development Branch to your Fork
-
-Once you've committed your changes to a local development branch, it's time to
-push them to your fork:
-
-```
-cd /path/to/thrust/checkout
-git checkout my_descriptive_branch_name # if not already checked out
-git push --set-upstream github-fork my_descriptive_branch_name
-```
-
-`--set-upstream github-fork` tells git that future pushes/pulls on this branch
-should target your `github-fork` remote by default.
-
-If have CUB changes to commit as part of your patch, repeat this process in the
-`thrust/dependencies/cub` submodule.
-
-## Create Pull Request
-
-To create a pull request for your freshly pushed branch, open your github fork
-in a browser by going to `https://www.github.com/<GITHUB_USERNAME>/thrust`. A
-prompt may automatically appear asking you to create a pull request if you've
-recently pushed a branch.
-
-If there's no prompt, go to "Code" > "Branches" and click the appropriate
-"New pull request" button for your branch.
-
-If you would like a specific developer to review your patch, feel free to
-request them as a reviewer at this time.
-
-The Thrust team will review your patch, test it on NVIDIA's internal CI, and
-provide feedback.
-
-
-If have CUB changes to commit as part of your patch, repeat this process with
-your CUB branch and fork.
-
-## Address Feedback and Update Pull Request
-
-If the reviewers request changes to your patch, use the following process to
-update the pull request:
-
-```
-# Make changes:
-cd /path/to/thrust/sources
-git checkout my_descriptive_branch_name
-emacs thrust/some_file.h
-emacs testing/some_test.cu
-
-# Build + test
-cd /path/to/thrust/build/directory
-cmake --build . -j <num jobs>
-ctest
-
-# Amend commit:
-cd /path/to/thrust/sources
-git add thrust/some_file.h
-git add testing/some_test.cu
-git commit --amend
-# Or
-git gui # Check the "Amend Last Commit" box
-
-# Update the branch on your fork:
-git push -f
-```
-
-At this point, the pull request should show your recent changes.
-
-If have CUB changes to commit as part of your patch, repeat this process in the
-`thrust/dependencies/cub` submodule, and be sure to include any CUB submodule
-updates as part of your commit.
-
-## When Your PR is Approved
-
-Once your pull request is approved by the Thrust team, no further action is
-needed from you. We will handle integrating it since we must coordinate changes
-to `master` with NVIDIA's internal perforce repository.
-
-# CMake Options
-
-A Thrust build is configured using CMake options. These may be passed to CMake
-using
-
-```
-cmake -D<option_name>=<value> /path/to/thrust/sources
-```
-
-or configured interactively with the `ccmake` or `cmake-gui` interfaces.
-
-Thrust supports two build modes. By default, a single configuration is built
-that targets a specific host system, device system, and C++ dialect.
-When `THRUST_ENABLE_MULTICONFIG` is `ON`, multiple configurations
-targeting a variety of systems and dialects are generated.
-
-The CMake options are divided into these categories:
-
-1. [Generic CMake Options](#generic-cmake-options): Options applicable to all
-   Thrust builds.
-1. [Single Config CMake Options](#single-config-cmake-options) Options
-   applicable only when `THRUST_ENABLE_MULTICONFIG` is disabled.
-1. [Multi Config CMake Options](#multi-config-cmake-options) Options applicable
-   only when `THRUST_ENABLE_MULTICONFIG` is enabled.
-1. [CUDA Specific CMake Options](#cuda-specific-cmake-options) Options that
-   control CUDA compilation. Only available when one or more configurations
-   targets the CUDA system.
-1. [TBB Specific CMake Options](#tbb-specific-cmake-options) Options that
-   control TBB compilation. Only available when one or more configurations
-   targets the TBB system.
-
-## Generic CMake Options
-
-- `CMAKE_BUILD_TYPE={Release, Debug, RelWithDebInfo, MinSizeRel}`
-  - Standard CMake build option. Default: `RelWithDebInfo`
-- `THRUST_ENABLE_HEADER_TESTING={ON, OFF}`
-  - Whether to test compile public headers. Default is `ON`.
-- `THRUST_ENABLE_TESTING={ON, OFF}`
-  - Whether to build unit tests. Default is `ON`.
-- `THRUST_ENABLE_EXAMPLES={ON, OFF}`
-  - Whether to build examples. Default is `ON`.
-- `THRUST_ENABLE_MULTICONFIG={ON, OFF}`
-  - Toggles single-config and multi-config modes. Default is `OFF` (single config).
-- `THRUST_ENABLE_EXAMPLE_FILECHECK={ON, OFF}`
-  - Enable validation of example outputs using the LLVM FileCheck utility.
-    Default is `OFF`.
-
-## Single Config CMake Options
-
-- `THRUST_HOST_SYSTEM={CPP, TBB, OMP}`
-  - Selects the host system. Default: `CPP`
-- `THRUST_DEVICE_SYSTEM={CUDA, TBB, OMP, CPP}`
-  - Selects the device system. Default: `CUDA`
-- `THRUST_CPP_DIALECT={11, 14, 17}`
-  - Selects the C++ standard dialect to use. Default is `14` (C++14).
-
-## Multi Config CMake Options
-
-- `THRUST_MULTICONFIG_ENABLE_DIALECT_CPPXX={ON, OFF}`
-  - Toggle whether a specific C++ dialect will be targeted.
-  - Possible values of `XX` are `{11, 14, 17}`.
-  - By default, only C++14 is enabled.
-- `THRUST_MULTICONFIG_ENABLE_SYSTEM_XXXX={ON, OFF}`
-  - Toggle whether a specific system will be targeted.
-  - Possible values of `XXXX` are `{CPP, CUDA, TBB, OMP}`
-  - By default, only `CPP` and `CUDA` are enabled.
-- `THRUST_MULTICONFIG_WORKLOAD={SMALL, MEDIUM, LARGE, FULL}`
-  - Restricts the host/device combinations that will be targeted.
-  - By default, the `SMALL` workload is used.
-  - The full cross product of `host x device` systems results in 12
-    configurations, some of which are more important than others.
-    This option can be used to prune some of the less important ones.
-  - `SMALL`: (3 configs) Minimal coverage and validation of each device system against the `CPP` host.
-  - `MEDIUM`: (6 configs) Cheap extended coverage.
-  - `LARGE`: (8 configs) Expensive extended coverage. Includes all useful build configurations.
-  - `FULL`: (12 configs) The complete cross product of all possible build configurations.
-
-| Config   | Workloads | Value      | Expense   | Note                         |
-|----------|-----------|------------|-----------|------------------------------|
-| CPP/CUDA | `F L M S` | Essential  | Expensive | Validates CUDA against CPP   |
-| CPP/OMP  | `F L M S` | Essential  | Cheap     | Validates OMP against CPP    |
-| CPP/TBB  | `F L M S` | Essential  | Cheap     | Validates TBB against CPP    |
-| CPP/CPP  | `F L M  ` | Important  | Cheap     | Tests CPP as device          |
-| OMP/OMP  | `F L M  ` | Important  | Cheap     | Tests OMP as host            |
-| TBB/TBB  | `F L M  ` | Important  | Cheap     | Tests TBB as host            |
-| TBB/CUDA | `F L    ` | Important  | Expensive | Validates TBB/CUDA interop   |
-| OMP/CUDA | `F L    ` | Important  | Expensive | Validates OMP/CUDA interop   |
-| TBB/OMP  | `F      ` | Not useful | Cheap     | Mixes CPU-parallel systems   |
-| OMP/TBB  | `F      ` | Not useful | Cheap     | Mixes CPU-parallel systems   |
-| TBB/CPP  | `F      ` | Not Useful | Cheap     | Parallel host, serial device |
-| OMP/CPP  | `F      ` | Not Useful | Cheap     | Parallel host, serial device |
-
-## CUDA Specific CMake Options
-
-- `THRUST_INCLUDE_CUB_CMAKE={ON, OFF}`
-  - If enabled, the CUB project will be built as part of Thrust. Default is
-    `OFF`.
-  - This adds CUB tests, etc. Useful for working on both CUB and Thrust
-    simultaneously.
-  - CUB configurations will be generated for each C++ dialect targeted by
-    the current Thrust build.
-- `THRUST_ENABLE_COMPUTE_XX={ON, OFF}`
-  - Controls the targeted CUDA architecture(s)
-  - Multiple options may be selected when using NVCC as the CUDA compiler.
-  - Valid values of `XX` are:
-    `{35, 37, 50, 52, 53, 60, 61, 62, 70, 72, 75, 80}`
-  - Default value depends on `THRUST_DISABLE_ARCH_BY_DEFAULT`:
-- `THRUST_ENABLE_COMPUTE_FUTURE={ON, OFF}`
-  - If enabled, CUDA objects will target the most recent virtual architecture
-    in addition to the real architectures specified by the
-    `THRUST_ENABLE_COMPUTE_XX` options.
-  - Default value depends on `THRUST_DISABLE_ARCH_BY_DEFAULT`:
-- `THRUST_DISABLE_ARCH_BY_DEFAULT={ON, OFF}`
-  - When `ON`, all `THRUST_ENABLE_COMPUTE_*` options are initially `OFF`.
-  - Default: `OFF` (meaning all architectures are enabled by default)
-- `THRUST_ENABLE_TESTS_WITH_RDC={ON, OFF}`
-  - Whether to enable Relocatable Device Code when building tests.
-    Default is `OFF`.
-- `THRUST_ENABLE_EXAMPLES_WITH_RDC={ON, OFF}`
-  - Whether to enable Relocatable Device Code when building examples.
-    Default is `OFF`.
-
-## TBB Specific CMake Options
-
-- `THRUST_TBB_ROOT=<path to tbb root>`
-  - When the TBB system is requested, set this to the root of the TBB installation
-    (e.g. the location of `lib/`, `bin/` and `include/` for the TBB libraries).
-
-# Development Model
-
-The following is a description of the basic development process that Thrust follows. This is a living
-document that will evolve as our process evolves.
-
-Thrust is distributed in three ways:
-
-   * On GitHub.
-   * In the NVIDIA HPC SDK.
-   * In the CUDA Toolkit.
-
-## Trunk Based Development
-
-Thrust uses [trunk based development](https://trunkbaseddevelopment.com). There is a single long-lived
-branch called `master`. Engineers may create branches for feature development. Such branches always
-merge into `master`. There are no release branches. Releases are produced by taking a snapshot of
-`master` ("snapping"). After a release has been snapped from `master`, it will never be changed.
-
-## Repositories
-
-As Thrust is developed both on GitHub and internally at NVIDIA, there are three main places where code lives:
-
-   * The Source of Truth, the [public Thrust repository](https://github.com/thrust/thrust), referred to as
-     `github` later in this document.
-   * An internal GitLab repository, referred to as `gitlab` later in this document.
-   * An internal Perforce repository, referred to as `perforce` later in this document.
-
-## Versioning
-
-Thrust has its own versioning system for releases, independent of the versioning scheme of the NVIDIA
-HPC SDK or the CUDA Toolkit.
-
-Today, Thrust version numbers have a specific [semantic meaning](https://semver.org/).
-Releases prior to 1.10.0 largely, but not strictly, followed these semantic meanings.
-
-The version number for a Thrust release uses the following format: `MMM.mmm.ss-ppp`, where:
-
-   * `THRUST_VERSION_MAJOR`/`MMM`: Major version, up to 3 decimal digits. It is incremented
-     when changes that are API-backwards-incompatible are made.
-   * `THRUST_VERSION_MINOR`/`mmm`: Minor version, up to 3 decimal digits. It is incremented when
-     breaking API, ABI, or semantic changes are made.
-   * `THRUST_VERSION_SUBMINOR`/`ss`: Subminor version, up to 2 decimal digits. It is incremented
-     when notable new features or bug fixes or features that are API-backwards-compatible are made.
-   * `THRUST_PATCH_NUMBER`/`ppp`: Patch number, up to 3 decimal digits. It is incremented if any
-     change in the repo whatsoever is made and no other version component has been incremented.
-
-The `<thrust/version.h>` header defines `THRUST_*` macros for all of the version components mentioned
-above. Additionally, a `THRUST_VERSION` macro is defined, which is an integer literal containing all
-of the version components except for `THRUST_PATCH_NUMBER`.
-
-## Branches and Tags
-
-The following tag names are used in the Thrust project:
-
-  * `github/nvhpc-X.Y`: the tag that directly corresponds to what has been shipped in the NVIDIA HPC SDK release X.Y.
-  * `github/cuda-X.Y`: the tag that directly corresponds to what has been shipped in the CUDA Toolkit release X.Y.
-  * `github/A.B.C`: the tag that directly corresponds to a Thrust version A.B.C.
-
-The following branch names are used in the Thrust project:
-
-  * `github/master`: the Source of Truth development branch of Thrust.
-  * `github/old-master`: the old Source of Truth branch, before unification of public and internal repositories.
-  * `github/feature/<name>`: feature branch for a feature under development.
-  * `github/bug/<bug-system>/<bug-description>-<bug-id>`: bug fix branch, where `bug-system` is `github` or `nvidia`.
-  * `gitlab/master`: mirror of `github/master`.
-  * `perforce/private`: mirrored `github/master`, plus files necessary for internal NVIDIA testing systems.
-
-On the rare occasion that we cannot do work in the open, for example when developing a change specific to an
-unreleased product, these branches may exist on `gitlab` instead of `github`. By default, everything should be
-in the open on `github` unless there is a strong motivation for it to not be open.
diff --git a/spaces/CVPR/LIVE/thrust/testing/omp/nvcc_independence.cpp b/spaces/CVPR/LIVE/thrust/testing/omp/nvcc_independence.cpp
deleted file mode 100644
index c870928a8a36c94cf9a835dceed99fb401524fb9..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/testing/omp/nvcc_independence.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include <unittest/unittest.h>
-#include <thrust/device_ptr.h>
-#include <thrust/transform.h>
-#include <thrust/reduce.h>
-#include <thrust/scan.h>
-#include <thrust/sort.h>
-#include <thrust/system_error.h>
-
-void TestNvccIndependenceTransform(void)
-{
-  typedef int T;
-  const int n = 10;
-
-  thrust::host_vector<T>   h_input = unittest::random_integers<T>(n);
-  thrust::device_vector<T> d_input = h_input;
-
-  thrust::host_vector<T>   h_output(n);
-  thrust::device_vector<T> d_output(n);
-
-  thrust::transform(h_input.begin(), h_input.end(), h_output.begin(), thrust::negate<T>());
-  thrust::transform(d_input.begin(), d_input.end(), d_output.begin(), thrust::negate<T>());
-  
-  ASSERT_EQUAL(h_output, d_output);
-}
-DECLARE_UNITTEST(TestNvccIndependenceTransform);
-
-void TestNvccIndependenceReduce(void)
-{
-  typedef int T;
-  const int n = 10;
-
-  thrust::host_vector<T>   h_data = unittest::random_integers<T>(n);
-  thrust::device_vector<T> d_data = h_data;
-
-  T init = 13;
-
-  T h_result = thrust::reduce(h_data.begin(), h_data.end(), init);
-  T d_result = thrust::reduce(d_data.begin(), d_data.end(), init);
-
-  ASSERT_ALMOST_EQUAL(h_result, d_result);
-}
-DECLARE_UNITTEST(TestNvccIndependenceReduce);
-
-void TestNvccIndependenceExclusiveScan(void)
-{
-  typedef int T;
-  const int n = 10;
-
-  thrust::host_vector<T>   h_input = unittest::random_integers<T>(n);
-  thrust::device_vector<T> d_input = h_input;
-
-  thrust::host_vector<T>   h_output(n);
-  thrust::device_vector<T> d_output(n);
-  
-  thrust::inclusive_scan(h_input.begin(), h_input.end(), h_output.begin());
-  thrust::inclusive_scan(d_input.begin(), d_input.end(), d_output.begin());
-  ASSERT_EQUAL(d_output, h_output);
-}
-DECLARE_UNITTEST(TestNvccIndependenceExclusiveScan);
-
-void TestNvccIndependenceSort(void)
-{
-  typedef int T;
-  const int n = 10;
-
-  thrust::host_vector<T>   h_data = unittest::random_integers<T>(n);
-  thrust::device_vector<T> d_data = h_data;
-
-  thrust::sort(h_data.begin(), h_data.end(), thrust::less<T>());
-  thrust::sort(d_data.begin(), d_data.end(), thrust::less<T>());
-
-  ASSERT_EQUAL(h_data, d_data);
-}
-DECLARE_UNITTEST(TestNvccIndependenceSort);
-
diff --git a/spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/equal.h b/spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/equal.h
deleted file mode 100644
index dd5e7d6863f378899330cc1e69d7667a87047338..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/equal.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/******************************************************************************
- * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION 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.
- *
- ******************************************************************************/
-#pragma once
-
-
-#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
-#include <thrust/system/cuda/config.h>
-
-#include <thrust/system/cuda/detail/mismatch.h>
-
-namespace thrust
-{
-namespace cuda_cub {
-
-template <class Derived,
-          class InputIt1,
-          class InputIt2,
-          class BinaryPred>
-bool __host__ __device__
-equal(execution_policy<Derived>& policy,
-      InputIt1                   first1,
-      InputIt1                   last1,
-      InputIt2                   first2,
-      BinaryPred                 binary_pred)
-{
-  return cuda_cub::mismatch(policy, first1, last1, first2, binary_pred).first == last1;
-}
-
-template <class Derived,
-          class InputIt1,
-          class InputIt2>
-bool __host__ __device__
-equal(execution_policy<Derived>& policy,
-      InputIt1                   first1,
-      InputIt1                   last1,
-      InputIt2                   first2)
-{
-  typedef typename thrust::iterator_value<InputIt1>::type InputType1;
-  return cuda_cub::equal(policy,
-                         first1,
-                         last1,
-                         first2,
-                         equal_to<InputType1>());
-}
-
-
-
-} // namespace cuda_cub
-} // end namespace thrust
-#endif
diff --git a/spaces/Caoyunkang/Segment-Any-Anomaly/GroundingDINO/groundingdino/models/GroundingDINO/backbone/position_encoding.py b/spaces/Caoyunkang/Segment-Any-Anomaly/GroundingDINO/groundingdino/models/GroundingDINO/backbone/position_encoding.py
deleted file mode 100644
index eac7e896bbe85a670824bfe8ef487d0535d5bd99..0000000000000000000000000000000000000000
--- a/spaces/Caoyunkang/Segment-Any-Anomaly/GroundingDINO/groundingdino/models/GroundingDINO/backbone/position_encoding.py
+++ /dev/null
@@ -1,186 +0,0 @@
-# ------------------------------------------------------------------------
-# Grounding DINO
-# url: https://github.com/IDEA-Research/GroundingDINO
-# Copyright (c) 2023 IDEA. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-# ------------------------------------------------------------------------
-# DINO
-# Copyright (c) 2022 IDEA. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-# ------------------------------------------------------------------------
-# Conditional DETR
-# Copyright (c) 2021 Microsoft. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-# ------------------------------------------------------------------------
-# Copied from DETR (https://github.com/facebookresearch/detr)
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-# ------------------------------------------------------------------------
-
-"""
-Various positional encodings for the transformer.
-"""
-import math
-
-import torch
-from torch import nn
-
-from groundingdino.util.misc import NestedTensor
-
-
-class PositionEmbeddingSine(nn.Module):
-    """
-    This is a more standard version of the position embedding, very similar to the one
-    used by the Attention is all you need paper, generalized to work on images.
-    """
-
-    def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None):
-        super().__init__()
-        self.num_pos_feats = num_pos_feats
-        self.temperature = temperature
-        self.normalize = normalize
-        if scale is not None and normalize is False:
-            raise ValueError("normalize should be True if scale is passed")
-        if scale is None:
-            scale = 2 * math.pi
-        self.scale = scale
-
-    def forward(self, tensor_list: NestedTensor):
-        x = tensor_list.tensors
-        mask = tensor_list.mask
-        assert mask is not None
-        not_mask = ~mask
-        y_embed = not_mask.cumsum(1, dtype=torch.float32)
-        x_embed = not_mask.cumsum(2, dtype=torch.float32)
-        if self.normalize:
-            eps = 1e-6
-            # if os.environ.get("SHILONG_AMP", None) == '1':
-            #     eps = 1e-4
-            # else:
-            #     eps = 1e-6
-            y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
-            x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
-
-        dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
-        dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
-
-        pos_x = x_embed[:, :, :, None] / dim_t
-        pos_y = y_embed[:, :, :, None] / dim_t
-        pos_x = torch.stack(
-            (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4
-        ).flatten(3)
-        pos_y = torch.stack(
-            (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4
-        ).flatten(3)
-        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
-        return pos
-
-
-class PositionEmbeddingSineHW(nn.Module):
-    """
-    This is a more standard version of the position embedding, very similar to the one
-    used by the Attention is all you need paper, generalized to work on images.
-    """
-
-    def __init__(
-        self, num_pos_feats=64, temperatureH=10000, temperatureW=10000, normalize=False, scale=None
-    ):
-        super().__init__()
-        self.num_pos_feats = num_pos_feats
-        self.temperatureH = temperatureH
-        self.temperatureW = temperatureW
-        self.normalize = normalize
-        if scale is not None and normalize is False:
-            raise ValueError("normalize should be True if scale is passed")
-        if scale is None:
-            scale = 2 * math.pi
-        self.scale = scale
-
-    def forward(self, tensor_list: NestedTensor):
-        x = tensor_list.tensors
-        mask = tensor_list.mask
-        assert mask is not None
-        not_mask = ~mask
-        y_embed = not_mask.cumsum(1, dtype=torch.float32)
-        x_embed = not_mask.cumsum(2, dtype=torch.float32)
-
-        # import ipdb; ipdb.set_trace()
-
-        if self.normalize:
-            eps = 1e-6
-            y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
-            x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
-
-        dim_tx = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
-        dim_tx = self.temperatureW ** (2 * (torch.div(dim_tx, 2, rounding_mode='floor')) / self.num_pos_feats)
-        pos_x = x_embed[:, :, :, None] / dim_tx
-
-        dim_ty = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
-        dim_ty = self.temperatureH ** (2 * (torch.div(dim_ty, 2, rounding_mode='floor')) / self.num_pos_feats)
-        pos_y = y_embed[:, :, :, None] / dim_ty
-
-        pos_x = torch.stack(
-            (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4
-        ).flatten(3)
-        pos_y = torch.stack(
-            (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4
-        ).flatten(3)
-        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
-
-        # import ipdb; ipdb.set_trace()
-
-        return pos
-
-
-class PositionEmbeddingLearned(nn.Module):
-    """
-    Absolute pos embedding, learned.
-    """
-
-    def __init__(self, num_pos_feats=256):
-        super().__init__()
-        self.row_embed = nn.Embedding(50, num_pos_feats)
-        self.col_embed = nn.Embedding(50, num_pos_feats)
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        nn.init.uniform_(self.row_embed.weight)
-        nn.init.uniform_(self.col_embed.weight)
-
-    def forward(self, tensor_list: NestedTensor):
-        x = tensor_list.tensors
-        h, w = x.shape[-2:]
-        i = torch.arange(w, device=x.device)
-        j = torch.arange(h, device=x.device)
-        x_emb = self.col_embed(i)
-        y_emb = self.row_embed(j)
-        pos = (
-            torch.cat(
-                [
-                    x_emb.unsqueeze(0).repeat(h, 1, 1),
-                    y_emb.unsqueeze(1).repeat(1, w, 1),
-                ],
-                dim=-1,
-            )
-            .permute(2, 0, 1)
-            .unsqueeze(0)
-            .repeat(x.shape[0], 1, 1, 1)
-        )
-        return pos
-
-
-def build_position_encoding(args):
-    N_steps = args.hidden_dim // 2
-    if args.position_embedding in ("v2", "sine"):
-        # TODO find a better way of exposing other arguments
-        position_embedding = PositionEmbeddingSineHW(
-            N_steps,
-            temperatureH=args.pe_temperatureH,
-            temperatureW=args.pe_temperatureW,
-            normalize=True,
-        )
-    elif args.position_embedding in ("v3", "learned"):
-        position_embedding = PositionEmbeddingLearned(N_steps)
-    else:
-        raise ValueError(f"not supported {args.position_embedding}")
-
-    return position_embedding
diff --git a/spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/components/Client.js b/spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/components/Client.js
deleted file mode 100644
index d66894fa336ffc885091447306c3b6b998c6f845..0000000000000000000000000000000000000000
--- a/spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/components/Client.js
+++ /dev/null
@@ -1,446 +0,0 @@
-import WebSocket, { WebSocketServer } from 'ws'
-import { getApiData, makeGSUidSendMsg, lifecycle, heartbeat, setMsgMap } from '../model/index.js'
-import { Version, Config } from './index.js'
-import express from "express"
-import http from "http"
-import fetch from 'node-fetch'
-
-export default class Client {
-    constructor({ name, address, type, reconnectInterval, maxReconnectAttempts, accessToken, uin = Bot.uin, closed = false }) {
-        this.name = name;
-        this.address = address;
-        this.type = type;
-        this.reconnectInterval = reconnectInterval;
-        this.maxReconnectAttempts = maxReconnectAttempts;
-        this.accessToken = accessToken;
-        this.uin = Number(uin)
-        this.ws = null
-        this.status = 0
-        this.closed = closed
-    }
-
-    reconnectCount = 1
-
-    timer = null
-
-    stopReconnect = false
-
-    createWs() {
-        try {
-            const headers = {
-                'X-Self-ID': this.uin,
-                'X-Client-Role': 'Universal',
-                'User-Agent': `ws-plugin/${Version.version}`
-            }
-            if (this.accessToken) headers["Authorization"] = 'Token ' + this.accessToken
-            this.ws = new WebSocket(this.address, { headers })
-        } catch (error) {
-            logger.error(`[ws-plugin] 出错了,可能是ws地址填错了~\nws名字: ${this.name}\n地址: ${this.address}\n类型: 1`)
-            return
-        }
-        this.ws.on('open', async () => {
-            logger.mark(`[ws-plugin] ${this.name} 已连接`);
-            if (this.status == 3 && this.reconnectCount > 1 && Config.reconnectToMaster) {
-                await this.sendMasterMsg(`${this.name} 重连成功~`)
-            } else if (this.status == 0 && Config.firstconnectToMaster) {
-                await this.sendMasterMsg(`${this.name} 连接成功~`)
-            }
-            this.ws.send(lifecycle(this.uin))
-            this.status = 1
-            this.reconnectCount = 1
-            if (Config.heartbeatInterval > 0) {
-                this.timer = setInterval(async () => {
-                    this.ws.send(heartbeat(this.uin))
-                }, Config.heartbeatInterval * 1000)
-            }
-        })
-        this.ws.on('message', async (event) => {
-            let data
-            if (Buffer.isBuffer(event)) {
-                data = JSON.parse(event.toString())
-            } else {
-                data = JSON.parse(event.data);
-            }
-            let result = await this.getData(data.action, data.params, data.echo)
-            this.ws.send(JSON.stringify(result));
-        })
-        this.ws.on('close', async code => {
-            logger.warn(`[ws-plugin] ${this.name} 连接已关闭`);
-            clearInterval(this.timer)
-            if (Config.disconnectToMaster && this.reconnectCount == 1 && this.status == 1) {
-                await this.sendMasterMsg(`${this.name} 已断开连接...`)
-            } else if (Config.firstconnectToMaster && this.reconnectCount == 1 && this.status == 0) {
-                await this.sendMasterMsg(`${this.name} 连接失败...`)
-            }
-            this.status = 3
-            if (!this.stopReconnect && ((this.reconnectCount < this.maxReconnectAttempts) || this.maxReconnectAttempts <= 0)) {
-                if (code === 1005) {
-                    logger.warn(`[ws-plugin] ${this.name} 连接异常,停止重连`);
-                    this.status = 0
-                } else {
-                    logger.warn(`[ws-plugin] ${this.name} 开始尝试重新连接第${this.reconnectCount}次`);
-                    this.reconnectCount++
-                    setTimeout(() => {
-                        this.createWs()
-                    }, this.reconnectInterval * 1000);
-                }
-            } else {
-                this.stopReconnect = false
-                this.status = 0
-                logger.warn(`[ws-plugin] ${this.name} 达到最大重连次数或关闭连接,停止重连`);
-            }
-        })
-        this.ws.on('error', (event) => {
-            logger.error(`[ws-plugin] ${this.name} 连接失败\n${event}`);
-        })
-    }
-
-    createServer() {
-        const parts = this.address.split(':');
-        this.host = parts[0];
-        this.port = parts[1];
-        this.arr = []
-        this.express = express()
-        this.server = http.createServer(this.express)
-        this.server.on("upgrade", (req, socket, head) => {
-            if (this.accessToken) {
-                const token = req.headers['authorization']?.replace('Token ', '')
-                if (!token) {
-                    socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
-                    socket.destroy();
-                    return
-                } else if (this.accessToken != token) {
-                    socket.write('HTTP/1.1 403 Forbidden\r\n\r\n');
-                    socket.destroy();
-                    return;
-                }
-            }
-            this.wss.handleUpgrade(req, socket, head, conn => {
-                if (req.url === '/') {
-                    conn.id = req.headers["sec-websocket-key"]
-                    let time = null
-                    conn.send(lifecycle(this.uin))
-                    if (Config.heartbeatInterval > 0) {
-                        time = setInterval(async () => {
-                            conn.send(heartbeat(this.uin))
-                        }, Config.heartbeatInterval * 1000)
-                    }
-                    logger.mark(`[ws-plugin] ${this.name} 接受 WebSocket 连接: ${req.connection.remoteAddress}`);
-                    conn.on("error", (event) => {
-                        logger.error(`[ws-plugin] ${this.name} 接受 WebSocket 连接时出现错误: ${event}`)
-                    })
-                    conn.on("close", () => {
-                        if (this.stopReconnect = false) {
-                            logger.warn(`[ws-plugin] ${this.name} 关闭 WebSocket 连接`);
-                        }
-                        this.arr = this.arr.filter(i => i.id != req.headers["sec-websocket-key"])
-                        clearInterval(time)
-                    })
-                    conn.on("message", async event => {
-                        const data = JSON.parse(event)
-                        const result = await this.getData(data.action, data.params, data.echo)
-                        conn.send(JSON.stringify(result));
-                    })
-                    this.arr.push(conn)
-                } else if (req.url === '/api' || req.url === '/api/') {
-                    logger.mark(`[ws-plugin] ${this.name} 接受 WebSocket api 连接: ${req.connection.remoteAddress}`);
-                    conn.on("error", (event) => {
-                        logger.error(`[ws-plugin] ${this.name} 接受 WebSocket api 连接时出现错误: ${event}`)
-                    })
-                    conn.on("close", () => {
-                        if (this.stopReconnect = false) {
-                            logger.warn(`[ws-plugin] ${this.name} 关闭 WebSocket api 连接`);
-                        }
-                    })
-                    conn.on("message", async event => {
-                        const data = JSON.parse(event)
-                        const result = await this.getData(data.action, data.params, data.echo)
-                        conn.send(JSON.stringify(result));
-                    })
-                } else if (req.url === '/event' || req.url === '/event/') {
-                    conn.id = req.headers["sec-websocket-key"]
-                    let time = null
-                    conn.send(lifecycle(this.uin))
-                    if (Config.heartbeatInterval > 0) {
-                        time = setInterval(async () => {
-                            conn.send(heartbeat(this.uin))
-                        }, Config.heartbeatInterval * 1000)
-                    }
-                    logger.mark(`[ws-plugin] ${this.name} 接受 WebSocket event 连接: ${req.connection.remoteAddress}`);
-                    conn.on("error", (event) => {
-                        logger.error(`[ws-plugin] ${this.name} 接受 WebSocket event 连接时出现错误: ${event}`)
-                    })
-                    conn.on("close", () => {
-                        if (this.stopReconnect = false) {
-                            logger.warn(`[ws-plugin] ${this.name} 关闭 WebSocket event 连接`);
-                        }
-                        this.arr = this.arr.filter(i => i.id != req.headers["sec-websocket-key"])
-                        clearInterval(time)
-                    })
-                    this.arr.push(conn)
-                }
-            })
-
-        })
-        this.ws = {
-            send: (msg) => {
-                for (const i of this.arr) {
-                    i.send(msg)
-                }
-            },
-            close: () => {
-                this.server.close()
-                logger.warn(`[ws-plugin] CQ WebSocket 服务器已关闭: ${this.host}:${this.port}`)
-                for (const i of this.arr) {
-                    i.close()
-                }
-            }
-        }
-        this.server.on('error', error => {
-            logger.error(`[ws-plugin] ${this.name} CQ WebSocket 服务器启动失败: ${this.host}:${this.port}`)
-            logger.error(error)
-        })
-        this.wss = new WebSocketServer({ noServer: true })
-        this.server.listen(this.port, this.host, () => {
-            this.status = 1
-            logger.mark(`[ws-plugin] CQ WebSocket 服务器已启动: ${this.host}:${this.port}`)
-        })
-    }
-
-    createGSUidWs() {
-        try {
-            this.ws = new WebSocket(this.address)
-        } catch (error) {
-            logger.error(`[ws-plugin] 出错了,可能是ws地址填错了~\nws名字: ${this.name}\n地址: ${this.address}\n类型: 3`)
-            return
-        }
-        this.ws.on('open', async () => {
-            logger.mark(`[ws-plugin] ${this.name} 已连接`);
-            if (this.status == 3 && this.reconnectCount > 1 && Config.reconnectToMaster) {
-                await this.sendMasterMsg(`${this.name} 重连成功~`)
-            } else if (this.status == 0 && Config.firstconnectToMaster) {
-                await this.sendMasterMsg(`${this.name} 连接成功~`)
-            }
-            this.status = 1
-            this.reconnectCount = 1
-        })
-
-        this.ws.on('message', async event => {
-            const data = JSON.parse(event.toString());
-            const { sendMsg, quote } = await makeGSUidSendMsg(data)
-            if (sendMsg.length > 0) {
-                let sendRet, group_id, user_id
-                // const bot = Version.isTrss ? Bot[data.bot_self_id] : Bot
-                const bot = Bot[data.bot_self_id] || Bot
-                switch (data.target_type) {
-                    case 'group':
-                    case 'channel':
-                        group_id = data.target_id
-                        sendRet = await bot.pickGroup(group_id).sendMsg(sendMsg, quote)
-                        break;
-                    case 'direct':
-                        user_id = data.target_id
-                        sendRet = await bot.pickFriend(user_id).sendMsg(sendMsg, quote)
-                        break;
-                    default:
-                        break;
-                }
-                if (sendRet.rand) {
-                    setMsgMap({
-                        message_id: sendRet.message_id,
-                        time: sendRet.time,
-                        seq: sendRet.seq,
-                        rand: sendRet.rand,
-                        user_id: user_id,
-                        group_id: group_id,
-                        onebot_id: Math.floor(Math.random() * Math.pow(2, 32)) | 0,
-                    })
-                }
-                logger.mark(`[ws-plugin] 连接名字:${this.name} 处理完成`)
-            }
-        })
-
-        this.ws.on('close', async code => {
-            logger.warn(`[ws-plugin] ${this.name} 连接已关闭`);
-            if (Config.disconnectToMaster && this.reconnectCount == 1 && this.status == 1) {
-                await this.sendMasterMsg(`${this.name} 已断开连接...`)
-            } else if (Config.firstconnectToMaster && this.reconnectCount == 1 && this.status == 0) {
-                await this.sendMasterMsg(`${this.name} 连接失败...`)
-            }
-            this.status = 3
-            if (!this.stopReconnect && ((this.reconnectCount < this.maxReconnectAttempts) || this.maxReconnectAttempts <= 0)) {
-                if (code === 1005) {
-                    logger.warn(`[ws-plugin] ${this.name} 连接异常,停止重连`);
-                    this.status = 0
-                } else {
-                    logger.warn(`[ws-plugin] ${this.name} 开始尝试重新连接第 ${this.reconnectCount} 次`);
-                    this.reconnectCount++
-                    setTimeout(() => {
-                        this.createGSUidWs()
-                    }, this.reconnectInterval * 1000);
-                }
-            } else {
-                this.stopReconnect = false
-                this.status = 0
-                logger.warn(`[ws-plugin] ${this.name} 达到最大重连次数或关闭连接,停止重连`);
-            }
-        })
-
-        this.ws.on('error', (event) => {
-            logger.error(`[ws-plugin] ${this.name} 连接失败\n${event}`);
-        })
-    }
-
-    createHttp() {
-        const parts = this.address.split(':');
-        this.host = parts[0];
-        this.port = parts[1];
-        this.express = express();
-        this.server = http.createServer(this.express);
-        this.express.use(express.json({ limit: '50mb' }));
-        this.express.use(express.urlencoded({ extended: true, limit: '50mb' }));
-        this.express.use((req, res, next) => this.authorization(req, res, next))
-
-        this.express.get('/:action', async (req, res) => {
-            const { action } = req.params;
-            const { query: params } = req;
-            const data = await this.getData(action, params)
-            res.status(200).json(data || {})
-        });
-
-        this.express.post('/:action', async (req, res) => {
-            const { action } = req.params;
-            const { body: params } = req;
-            const data = await this.getData(action, params)
-            res.status(200).json(data || {})
-        });
-
-        this.express.post('/', async (req, res) => {
-            const { action, params } = req.body;
-            const data = await this.getData(action, params)
-            res.status(200).json(data || {})
-        });
-
-        this.server.on('error', error => {
-            logger.error(`[ws-plugin] ${this.name} 正向HTTP 服务器启动失败: ${this.host}:${this.port}`)
-            logger.error(error)
-        })
-        this.server.listen(this.port, this.host, () => {
-            this.status = 1
-            logger.mark(`[ws-plugin] HTTP 服务器已启动: ${this.host}:${this.port}`)
-        })
-        this.ws = {
-            close: () => {
-                this.server.close()
-                logger.warn(`[ws-plugin] 正向HTTP 服务器已关闭: ${this.host}:${this.port}`)
-            }
-        }
-    }
-
-    createHttpPost() {
-        if (!this.address.startsWith('http')) {
-            this.address = 'http://' + this.address
-        }
-        this.status = 1
-        // 心跳咕一下
-        this.ws = {
-            send: body => {
-                fetch(this.address, {
-                    method: 'POST',
-                    headers: {
-                        'content-type': 'application/json',
-                        'x-self-id': this.uin,
-                        'user-agent': `ws-plugin/${Version.version}`
-                    },
-                    body
-                })
-            }
-        }
-    }
-
-    close() {
-        this.stopReconnect = true
-        if (this.status == 1) {
-            this.ws?.close?.()
-            this.status = 0
-        }
-    }
-
-    authorization(req, res, next) {
-        let code = null
-        const token = req.headers['authorization']?.replace?.(/^(Token|Bearer) /, '') || req.query.access_token
-        if (this.accessToken) {
-            if (!token) {
-                code = 401
-            } else if (this.accessToken != token) {
-                code = 403
-            }
-        }
-        if (code) {
-            res.status(code).end()
-            return
-        }
-        next()
-    }
-
-    async getData(action, params, echo) {
-        let result
-        try {
-            const data = await getApiData(action, params, this.name, this.uin);
-            result = {
-                status: 'ok',
-                retcode: 0,
-                data,
-                echo
-            }
-        } catch (error) {
-            if (!error.noLog) logger.error('ws-plugin出现错误', error)
-            result = {
-                status: 'failed',
-                retcode: -1,
-                msg: error.message,
-                wording: 'ws-plugin获取信息失败',
-                echo
-            }
-        } finally {
-            return result
-        }
-    }
-
-    async sendMasterMsg(msg) {
-        // const bot = Version.isTrss ? Bot[this.uin] : Bot
-        const bot = Bot[this.uin] || Bot
-        let masterQQ = []
-        const master = Version.isTrss ? Config.master[this.uin] : Config.masterQQ
-        if (Config.howToMaster > 0) {
-            masterQQ.push(master?.[Config.howToMaster - 1])
-        } else if (Config.howToMaster == 0) {
-            masterQQ.push(...master)
-        }
-        for (const i of masterQQ) {
-            if (!i) continue
-            let result
-            try {
-                result = await bot?.pickFriend?.(i)?.sendMsg?.(msg) || true
-            } catch (error) {
-                result = true
-            }
-            if (result) {
-                logger.mark(`[ws-plugin] 连接名字:${this.name} 通知主人:${i} 处理完成`)
-            } else {
-                const timer = setInterval(async () => {
-                    try {
-                        result = await bot?.pickFriend?.(i)?.sendMsg?.(msg) || true
-                    } catch (error) {
-                        result = true
-                    }
-                    if (result) {
-                        clearInterval(timer)
-                        logger.mark(`[ws-plugin] 连接名字:${this.name} 通知主人:${i} 处理完成`)
-                    }
-                }, 5000)
-            }
-        }
-    }
-
-}
\ No newline at end of file
diff --git a/spaces/CrucibleAI/ControlNetMediaPipeFaceSD21/ldm/modules/encoders/modules.py b/spaces/CrucibleAI/ControlNetMediaPipeFaceSD21/ldm/modules/encoders/modules.py
deleted file mode 100644
index a04697ab65c0446c0ffedaa415257898e4880a9c..0000000000000000000000000000000000000000
--- a/spaces/CrucibleAI/ControlNetMediaPipeFaceSD21/ldm/modules/encoders/modules.py
+++ /dev/null
@@ -1,226 +0,0 @@
-import torch
-import torch.nn as nn
-from torch.utils.checkpoint import checkpoint
-
-from transformers import T5Tokenizer, T5EncoderModel, CLIPTokenizer, CLIPTextModel
-
-import open_clip
-from ldm.util import default, count_params
-
-
-default_device = torch.device("cpu" if not torch.cuda.is_available() else "cuda")
-
-
-class AbstractEncoder(nn.Module):
-    def __init__(self):
-        super().__init__()
-
-    def encode(self, *args, **kwargs):
-        raise NotImplementedError
-
-
-class IdentityEncoder(AbstractEncoder):
-
-    def encode(self, x):
-        return x
-
-
-class ClassEmbedder(nn.Module):
-    def __init__(self, embed_dim, n_classes=1000, key='class', ucg_rate=0.1):
-        super().__init__()
-        self.key = key
-        self.embedding = nn.Embedding(n_classes, embed_dim)
-        self.n_classes = n_classes
-        self.ucg_rate = ucg_rate
-
-    def forward(self, batch, key=None, disable_dropout=False):
-        if key is None:
-            key = self.key
-        # this is for use in crossattn
-        c = batch[key][:, None]
-        if self.ucg_rate > 0. and not disable_dropout:
-            mask = 1. - torch.bernoulli(torch.ones_like(c) * self.ucg_rate)
-            c = mask * c + (1-mask) * torch.ones_like(c)*(self.n_classes-1)
-            c = c.long()
-        c = self.embedding(c)
-        return c
-
-    def get_unconditional_conditioning(self, bs, device=None):
-        if device is None:
-            device = default_device
-        uc_class = self.n_classes - 1  # 1000 classes --> 0 ... 999, one extra class for ucg (class 1000)
-        uc = torch.ones((bs,), device=device) * uc_class
-        uc = {self.key: uc}
-        return uc
-
-
-def disabled_train(self, mode=True):
-    """Overwrite model.train with this function to make sure train/eval mode
-    does not change anymore."""
-    return self
-
-
-class FrozenT5Embedder(AbstractEncoder):
-    """Uses the T5 transformer encoder for text"""
-    def __init__(self, version="google/t5-v1_1-large", device=None, max_length=77, freeze=True):  # others are google/t5-v1_1-xl and google/t5-v1_1-xxl
-        super().__init__()
-        if device is None:
-            device = default_device
-        self.tokenizer = T5Tokenizer.from_pretrained(version)
-        self.transformer = T5EncoderModel.from_pretrained(version)
-        self.device = device
-        self.max_length = max_length   # TODO: typical value?
-        if freeze:
-            self.freeze()
-
-    def freeze(self):
-        self.transformer = self.transformer.eval()
-        #self.train = disabled_train
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, text):
-        batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True,
-                                        return_overflowing_tokens=False, padding="max_length", return_tensors="pt")
-        tokens = batch_encoding["input_ids"].to(self.device)
-        outputs = self.transformer(input_ids=tokens)
-
-        z = outputs.last_hidden_state
-        return z
-
-    def encode(self, text):
-        return self(text)
-
-
-class FrozenCLIPEmbedder(AbstractEncoder):
-    """Uses the CLIP transformer encoder for text (from huggingface)"""
-    LAYERS = [
-        "last",
-        "pooled",
-        "hidden"
-    ]
-    def __init__(self, version="openai/clip-vit-large-patch14", device=None, max_length=77,
-                 freeze=True, layer="last", layer_idx=None):  # clip-vit-base-patch32
-        super().__init__()
-        if device is None:
-            device = default_device
-        assert layer in self.LAYERS
-        self.tokenizer = CLIPTokenizer.from_pretrained(version)
-        self.transformer = CLIPTextModel.from_pretrained(version)
-        self.device = device
-        self.max_length = max_length
-        if freeze:
-            self.freeze()
-        self.layer = layer
-        self.layer_idx = layer_idx
-        if layer == "hidden":
-            assert layer_idx is not None
-            assert 0 <= abs(layer_idx) <= 12
-
-    def freeze(self):
-        self.transformer = self.transformer.eval()
-        #self.train = disabled_train
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, text):
-        batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True,
-                                        return_overflowing_tokens=False, padding="max_length", return_tensors="pt")
-        tokens = batch_encoding["input_ids"].to(self.device)
-        outputs = self.transformer(input_ids=tokens, output_hidden_states=self.layer=="hidden")
-        if self.layer == "last":
-            z = outputs.last_hidden_state
-        elif self.layer == "pooled":
-            z = outputs.pooler_output[:, None, :]
-        else:
-            z = outputs.hidden_states[self.layer_idx]
-        return z
-
-    def encode(self, text):
-        return self(text)
-
-
-class FrozenOpenCLIPEmbedder(AbstractEncoder):
-    """
-    Uses the OpenCLIP transformer encoder for text
-    """
-    LAYERS = [
-        #"pooled",
-        "last",
-        "penultimate"
-    ]
-    def __init__(self, arch="ViT-H-14", version="laion2b_s32b_b79k", device=None, max_length=77,
-                 freeze=True, layer="last"):
-        super().__init__()
-        if device is None:
-            device = default_device
-        assert layer in self.LAYERS
-        model, _, _ = open_clip.create_model_and_transforms(arch, device=torch.device('cpu'), pretrained=version)
-        del model.visual
-        self.model = model
-
-        self.device = device
-        self.max_length = max_length
-        if freeze:
-            self.freeze()
-        self.layer = layer
-        if self.layer == "last":
-            self.layer_idx = 0
-        elif self.layer == "penultimate":
-            self.layer_idx = 1
-        else:
-            raise NotImplementedError()
-
-    def freeze(self):
-        self.model = self.model.eval()
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, text):
-        tokens = open_clip.tokenize(text)
-        z = self.encode_with_transformer(tokens.to(self.device))
-        return z
-
-    def encode_with_transformer(self, text):
-        x = self.model.token_embedding(text)  # [batch_size, n_ctx, d_model]
-        x = x + self.model.positional_embedding
-        x = x.permute(1, 0, 2)  # NLD -> LND
-        x = self.text_transformer_forward(x, attn_mask=self.model.attn_mask)
-        x = x.permute(1, 0, 2)  # LND -> NLD
-        x = self.model.ln_final(x)
-        return x
-
-    def text_transformer_forward(self, x: torch.Tensor, attn_mask = None):
-        for i, r in enumerate(self.model.transformer.resblocks):
-            if i == len(self.model.transformer.resblocks) - self.layer_idx:
-                break
-            if self.model.transformer.grad_checkpointing and not torch.jit.is_scripting():
-                x = checkpoint(r, x, attn_mask)
-            else:
-                x = r(x, attn_mask=attn_mask)
-        return x
-
-    def encode(self, text):
-        return self(text)
-
-
-class FrozenCLIPT5Encoder(AbstractEncoder):
-    def __init__(self, clip_version="openai/clip-vit-large-patch14", t5_version="google/t5-v1_1-xl", device=None,
-                 clip_max_length=77, t5_max_length=77):
-        super().__init__()
-        if device is None:
-            device = default_device
-        self.clip_encoder = FrozenCLIPEmbedder(clip_version, device, max_length=clip_max_length)
-        self.t5_encoder = FrozenT5Embedder(t5_version, device, max_length=t5_max_length)
-        print(f"{self.clip_encoder.__class__.__name__} has {count_params(self.clip_encoder)*1.e-6:.2f} M parameters, "
-              f"{self.t5_encoder.__class__.__name__} comes with {count_params(self.t5_encoder)*1.e-6:.2f} M params.")
-
-    def encode(self, text):
-        return self(text)
-
-    def forward(self, text):
-        clip_z = self.clip_encoder.encode(text)
-        t5_z = self.t5_encoder.encode(text)
-        return [clip_z, t5_z]
-
-
diff --git a/spaces/Curranj/GPT-QRI/app.py b/spaces/Curranj/GPT-QRI/app.py
deleted file mode 100644
index 6f3e71e1da47f0d3d9abb67cbd5800b1fcdf55d6..0000000000000000000000000000000000000000
--- a/spaces/Curranj/GPT-QRI/app.py
+++ /dev/null
@@ -1,78 +0,0 @@
-import sklearn
-import sqlite3
-import numpy as np
-from sklearn.metrics.pairwise import cosine_similarity
-import openai
-import os
-import gradio as gr
-
-
-openai.api_key = os.environ["Secret"] 
-
-def find_closest_neighbors(vector1, dictionary_of_vectors):
-    """
-    Takes a vector and a dictionary of vectors and returns the three closest neighbors
-    """
-    vector = openai.Embedding.create(
-        input=vector1,
-        engine="text-embedding-ada-002"
-    )['data'][0]['embedding']
-
-    vector = np.array(vector)
-
-    cosine_similarities = {}
-    for key, value in dictionary_of_vectors.items():
-        cosine_similarities[key] = cosine_similarity(vector.reshape(1, -1), value.reshape(1, -1))[0][0]
-
-    sorted_cosine_similarities = sorted(cosine_similarities.items(), key=lambda x: x[1], reverse=True)
-    match_list = sorted_cosine_similarities[0:4]
-
-    return match_list
-
-def predict(message, history):
-    # Connect to the database
-    conn = sqlite3.connect('QRIdatabase7.db')
-    cursor = conn.cursor()
-    cursor.execute('''SELECT text, embedding FROM chunks''')
-    rows = cursor.fetchall()
-
-    dictionary_of_vectors = {}
-    for row in rows:
-        text = row[0]
-        embedding_str = row[1]
-        embedding = np.fromstring(embedding_str, sep=' ')
-        dictionary_of_vectors[text] = embedding
-    conn.close()
-
-    # Find the closest neighbors
-    match_list = find_closest_neighbors(message, dictionary_of_vectors)
-    context = ''
-    for match in match_list:
-        context += str(match[0])
-    context = context[:-1500]
-
-    prep = f"This is an OpenAI model tuned to answer questions specific to the Qualia Research institute, a research institute that focuses on consciousness. Here is some question-specific context, and then the Question to answer, related to consciousness, the human experience, and phenomenology: {context}. Here is a question specific to QRI and consciousness in general Q:  {message}  A: "
-
-    history_openai_format = []
-    for human, assistant in history:
-        history_openai_format.append({"role": "user", "content": human })
-        history_openai_format.append({"role": "assistant", "content":assistant})
-    history_openai_format.append({"role": "user", "content": prep})
-
-    response = openai.ChatCompletion.create(
-        model='gpt-3.5-turbo',
-        messages= history_openai_format,         
-        temperature=1.0,
-        stream=True
-    )
-    
-    partial_message = ""
-    for chunk in response:
-        if len(chunk['choices'][0]['delta']) != 0:
-            partial_message = partial_message + chunk['choices'][0]['delta']['content']
-            yield partial_message 
-
-demo = gr.ChatInterface(predict).queue()
-
-if __name__ == "__main__":
-    demo.launch()
diff --git a/spaces/DAMO-NLP-SG/Video-LLaMA/video_llama/datasets/builders/__init__.py b/spaces/DAMO-NLP-SG/Video-LLaMA/video_llama/datasets/builders/__init__.py
deleted file mode 100644
index 0b160d0b8ad5793e368d8b2d26ff9829fa3ddd9a..0000000000000000000000000000000000000000
--- a/spaces/DAMO-NLP-SG/Video-LLaMA/video_llama/datasets/builders/__init__.py
+++ /dev/null
@@ -1,77 +0,0 @@
-"""
- Copyright (c) 2022, salesforce.com, inc.
- All rights reserved.
- SPDX-License-Identifier: BSD-3-Clause
- For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
-"""
-
-from video_llama.datasets.builders.base_dataset_builder import load_dataset_config
-from video_llama.datasets.builders.image_text_pair_builder import (
-    CCSBUBuilder,
-    LaionBuilder,
-    CCSBUAlignBuilder
-)
-from video_llama.datasets.builders.video_caption_builder import WebvidBuilder
-from video_llama.common.registry import registry
-from video_llama.datasets.builders.instruct_builder import WebvidInstruct_Builder,LlavaInstruct_Builder
-__all__ = [
-    "CCSBUBuilder",
-    "LaionBuilder",
-    "CCSBUAlignBuilder",
-    "WebvidBuilder",
-    "LlavaInstruct_Builder",
-    "WebvidInstruct_Builder"
-    
-]
-
-
-def load_dataset(name, cfg_path=None, vis_path=None, data_type=None):
-    """
-    Example
-
-    >>> dataset = load_dataset("coco_caption", cfg=None)
-    >>> splits = dataset.keys()
-    >>> print([len(dataset[split]) for split in splits])
-
-    """
-    if cfg_path is None:
-        cfg = None
-    else:
-        cfg = load_dataset_config(cfg_path)
-
-    try:
-        builder = registry.get_builder_class(name)(cfg)
-    except TypeError:
-        print(
-            f"Dataset {name} not found. Available datasets:\n"
-            + ", ".join([str(k) for k in dataset_zoo.get_names()])
-        )
-        exit(1)
-
-    if vis_path is not None:
-        if data_type is None:
-            # use default data type in the config
-            data_type = builder.config.data_type
-
-        assert (
-            data_type in builder.config.build_info
-        ), f"Invalid data_type {data_type} for {name}."
-
-        builder.config.build_info.get(data_type).storage = vis_path
-
-    dataset = builder.build_datasets()
-    return dataset
-
-
-class DatasetZoo:
-    def __init__(self) -> None:
-        self.dataset_zoo = {
-            k: list(v.DATASET_CONFIG_DICT.keys())
-            for k, v in sorted(registry.mapping["builder_name_mapping"].items())
-        }
-
-    def get_names(self):
-        return list(self.dataset_zoo.keys())
-
-
-dataset_zoo = DatasetZoo()
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/ImageDraw.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/ImageDraw.py
deleted file mode 100644
index 7d1790faa93e98dbdf32b1c3d1dd4b49b65e7cc0..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/ImageDraw.py
+++ /dev/null
@@ -1,1038 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# drawing interface operations
-#
-# History:
-# 1996-04-13 fl   Created (experimental)
-# 1996-08-07 fl   Filled polygons, ellipses.
-# 1996-08-13 fl   Added text support
-# 1998-06-28 fl   Handle I and F images
-# 1998-12-29 fl   Added arc; use arc primitive to draw ellipses
-# 1999-01-10 fl   Added shape stuff (experimental)
-# 1999-02-06 fl   Added bitmap support
-# 1999-02-11 fl   Changed all primitives to take options
-# 1999-02-20 fl   Fixed backwards compatibility
-# 2000-10-12 fl   Copy on write, when necessary
-# 2001-02-18 fl   Use default ink for bitmap/text also in fill mode
-# 2002-10-24 fl   Added support for CSS-style color strings
-# 2002-12-10 fl   Added experimental support for RGBA-on-RGB drawing
-# 2002-12-11 fl   Refactored low-level drawing API (work in progress)
-# 2004-08-26 fl   Made Draw() a factory function, added getdraw() support
-# 2004-09-04 fl   Added width support to line primitive
-# 2004-09-10 fl   Added font mode handling
-# 2006-06-19 fl   Added font bearing support (getmask2)
-#
-# Copyright (c) 1997-2006 by Secret Labs AB
-# Copyright (c) 1996-2006 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import math
-import numbers
-
-from . import Image, ImageColor
-
-"""
-A simple 2D drawing interface for PIL images.
-<p>
-Application code should use the <b>Draw</b> factory, instead of
-directly.
-"""
-
-
-class ImageDraw:
-    font = None
-
-    def __init__(self, im, mode=None):
-        """
-        Create a drawing instance.
-
-        :param im: The image to draw in.
-        :param mode: Optional mode to use for color values.  For RGB
-           images, this argument can be RGB or RGBA (to blend the
-           drawing into the image).  For all other modes, this argument
-           must be the same as the image mode.  If omitted, the mode
-           defaults to the mode of the image.
-        """
-        im.load()
-        if im.readonly:
-            im._copy()  # make it writeable
-        blend = 0
-        if mode is None:
-            mode = im.mode
-        if mode != im.mode:
-            if mode == "RGBA" and im.mode == "RGB":
-                blend = 1
-            else:
-                msg = "mode mismatch"
-                raise ValueError(msg)
-        if mode == "P":
-            self.palette = im.palette
-        else:
-            self.palette = None
-        self._image = im
-        self.im = im.im
-        self.draw = Image.core.draw(self.im, blend)
-        self.mode = mode
-        if mode in ("I", "F"):
-            self.ink = self.draw.draw_ink(1)
-        else:
-            self.ink = self.draw.draw_ink(-1)
-        if mode in ("1", "P", "I", "F"):
-            # FIXME: fix Fill2 to properly support matte for I+F images
-            self.fontmode = "1"
-        else:
-            self.fontmode = "L"  # aliasing is okay for other modes
-        self.fill = False
-
-    def getfont(self):
-        """
-        Get the current default font.
-
-        To set the default font for this ImageDraw instance::
-
-            from PIL import ImageDraw, ImageFont
-            draw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
-
-        To set the default font for all future ImageDraw instances::
-
-            from PIL import ImageDraw, ImageFont
-            ImageDraw.ImageDraw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
-
-        If the current default font is ``None``,
-        it is initialized with ``ImageFont.load_default()``.
-
-        :returns: An image font."""
-        if not self.font:
-            # FIXME: should add a font repository
-            from . import ImageFont
-
-            self.font = ImageFont.load_default()
-        return self.font
-
-    def _getink(self, ink, fill=None):
-        if ink is None and fill is None:
-            if self.fill:
-                fill = self.ink
-            else:
-                ink = self.ink
-        else:
-            if ink is not None:
-                if isinstance(ink, str):
-                    ink = ImageColor.getcolor(ink, self.mode)
-                if self.palette and not isinstance(ink, numbers.Number):
-                    ink = self.palette.getcolor(ink, self._image)
-                ink = self.draw.draw_ink(ink)
-            if fill is not None:
-                if isinstance(fill, str):
-                    fill = ImageColor.getcolor(fill, self.mode)
-                if self.palette and not isinstance(fill, numbers.Number):
-                    fill = self.palette.getcolor(fill, self._image)
-                fill = self.draw.draw_ink(fill)
-        return ink, fill
-
-    def arc(self, xy, start, end, fill=None, width=1):
-        """Draw an arc."""
-        ink, fill = self._getink(fill)
-        if ink is not None:
-            self.draw.draw_arc(xy, start, end, ink, width)
-
-    def bitmap(self, xy, bitmap, fill=None):
-        """Draw a bitmap."""
-        bitmap.load()
-        ink, fill = self._getink(fill)
-        if ink is None:
-            ink = fill
-        if ink is not None:
-            self.draw.draw_bitmap(xy, bitmap.im, ink)
-
-    def chord(self, xy, start, end, fill=None, outline=None, width=1):
-        """Draw a chord."""
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_chord(xy, start, end, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            self.draw.draw_chord(xy, start, end, ink, 0, width)
-
-    def ellipse(self, xy, fill=None, outline=None, width=1):
-        """Draw an ellipse."""
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_ellipse(xy, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            self.draw.draw_ellipse(xy, ink, 0, width)
-
-    def line(self, xy, fill=None, width=0, joint=None):
-        """Draw a line, or a connected sequence of line segments."""
-        ink = self._getink(fill)[0]
-        if ink is not None:
-            self.draw.draw_lines(xy, ink, width)
-            if joint == "curve" and width > 4:
-                if not isinstance(xy[0], (list, tuple)):
-                    xy = [tuple(xy[i : i + 2]) for i in range(0, len(xy), 2)]
-                for i in range(1, len(xy) - 1):
-                    point = xy[i]
-                    angles = [
-                        math.degrees(math.atan2(end[0] - start[0], start[1] - end[1]))
-                        % 360
-                        for start, end in ((xy[i - 1], point), (point, xy[i + 1]))
-                    ]
-                    if angles[0] == angles[1]:
-                        # This is a straight line, so no joint is required
-                        continue
-
-                    def coord_at_angle(coord, angle):
-                        x, y = coord
-                        angle -= 90
-                        distance = width / 2 - 1
-                        return tuple(
-                            p + (math.floor(p_d) if p_d > 0 else math.ceil(p_d))
-                            for p, p_d in (
-                                (x, distance * math.cos(math.radians(angle))),
-                                (y, distance * math.sin(math.radians(angle))),
-                            )
-                        )
-
-                    flipped = (
-                        angles[1] > angles[0] and angles[1] - 180 > angles[0]
-                    ) or (angles[1] < angles[0] and angles[1] + 180 > angles[0])
-                    coords = [
-                        (point[0] - width / 2 + 1, point[1] - width / 2 + 1),
-                        (point[0] + width / 2 - 1, point[1] + width / 2 - 1),
-                    ]
-                    if flipped:
-                        start, end = (angles[1] + 90, angles[0] + 90)
-                    else:
-                        start, end = (angles[0] - 90, angles[1] - 90)
-                    self.pieslice(coords, start - 90, end - 90, fill)
-
-                    if width > 8:
-                        # Cover potential gaps between the line and the joint
-                        if flipped:
-                            gap_coords = [
-                                coord_at_angle(point, angles[0] + 90),
-                                point,
-                                coord_at_angle(point, angles[1] + 90),
-                            ]
-                        else:
-                            gap_coords = [
-                                coord_at_angle(point, angles[0] - 90),
-                                point,
-                                coord_at_angle(point, angles[1] - 90),
-                            ]
-                        self.line(gap_coords, fill, width=3)
-
-    def shape(self, shape, fill=None, outline=None):
-        """(Experimental) Draw a shape."""
-        shape.close()
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_outline(shape, fill, 1)
-        if ink is not None and ink != fill:
-            self.draw.draw_outline(shape, ink, 0)
-
-    def pieslice(self, xy, start, end, fill=None, outline=None, width=1):
-        """Draw a pieslice."""
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_pieslice(xy, start, end, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            self.draw.draw_pieslice(xy, start, end, ink, 0, width)
-
-    def point(self, xy, fill=None):
-        """Draw one or more individual pixels."""
-        ink, fill = self._getink(fill)
-        if ink is not None:
-            self.draw.draw_points(xy, ink)
-
-    def polygon(self, xy, fill=None, outline=None, width=1):
-        """Draw a polygon."""
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_polygon(xy, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            if width == 1:
-                self.draw.draw_polygon(xy, ink, 0, width)
-            else:
-                # To avoid expanding the polygon outwards,
-                # use the fill as a mask
-                mask = Image.new("1", self.im.size)
-                mask_ink = self._getink(1)[0]
-
-                fill_im = mask.copy()
-                draw = Draw(fill_im)
-                draw.draw.draw_polygon(xy, mask_ink, 1)
-
-                ink_im = mask.copy()
-                draw = Draw(ink_im)
-                width = width * 2 - 1
-                draw.draw.draw_polygon(xy, mask_ink, 0, width)
-
-                mask.paste(ink_im, mask=fill_im)
-
-                im = Image.new(self.mode, self.im.size)
-                draw = Draw(im)
-                draw.draw.draw_polygon(xy, ink, 0, width)
-                self.im.paste(im.im, (0, 0) + im.size, mask.im)
-
-    def regular_polygon(
-        self, bounding_circle, n_sides, rotation=0, fill=None, outline=None, width=1
-    ):
-        """Draw a regular polygon."""
-        xy = _compute_regular_polygon_vertices(bounding_circle, n_sides, rotation)
-        self.polygon(xy, fill, outline, width)
-
-    def rectangle(self, xy, fill=None, outline=None, width=1):
-        """Draw a rectangle."""
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_rectangle(xy, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            self.draw.draw_rectangle(xy, ink, 0, width)
-
-    def rounded_rectangle(
-        self, xy, radius=0, fill=None, outline=None, width=1, *, corners=None
-    ):
-        """Draw a rounded rectangle."""
-        if isinstance(xy[0], (list, tuple)):
-            (x0, y0), (x1, y1) = xy
-        else:
-            x0, y0, x1, y1 = xy
-        if x1 < x0:
-            msg = "x1 must be greater than or equal to x0"
-            raise ValueError(msg)
-        if y1 < y0:
-            msg = "y1 must be greater than or equal to y0"
-            raise ValueError(msg)
-        if corners is None:
-            corners = (True, True, True, True)
-
-        d = radius * 2
-
-        full_x, full_y = False, False
-        if all(corners):
-            full_x = d >= x1 - x0 - 1
-            if full_x:
-                # The two left and two right corners are joined
-                d = x1 - x0
-            full_y = d >= y1 - y0 - 1
-            if full_y:
-                # The two top and two bottom corners are joined
-                d = y1 - y0
-            if full_x and full_y:
-                # If all corners are joined, that is a circle
-                return self.ellipse(xy, fill, outline, width)
-
-        if d == 0 or not any(corners):
-            # If the corners have no curve,
-            # or there are no corners,
-            # that is a rectangle
-            return self.rectangle(xy, fill, outline, width)
-
-        r = d // 2
-        ink, fill = self._getink(outline, fill)
-
-        def draw_corners(pieslice):
-            if full_x:
-                # Draw top and bottom halves
-                parts = (
-                    ((x0, y0, x0 + d, y0 + d), 180, 360),
-                    ((x0, y1 - d, x0 + d, y1), 0, 180),
-                )
-            elif full_y:
-                # Draw left and right halves
-                parts = (
-                    ((x0, y0, x0 + d, y0 + d), 90, 270),
-                    ((x1 - d, y0, x1, y0 + d), 270, 90),
-                )
-            else:
-                # Draw four separate corners
-                parts = []
-                for i, part in enumerate(
-                    (
-                        ((x0, y0, x0 + d, y0 + d), 180, 270),
-                        ((x1 - d, y0, x1, y0 + d), 270, 360),
-                        ((x1 - d, y1 - d, x1, y1), 0, 90),
-                        ((x0, y1 - d, x0 + d, y1), 90, 180),
-                    )
-                ):
-                    if corners[i]:
-                        parts.append(part)
-            for part in parts:
-                if pieslice:
-                    self.draw.draw_pieslice(*(part + (fill, 1)))
-                else:
-                    self.draw.draw_arc(*(part + (ink, width)))
-
-        if fill is not None:
-            draw_corners(True)
-
-            if full_x:
-                self.draw.draw_rectangle((x0, y0 + r + 1, x1, y1 - r - 1), fill, 1)
-            else:
-                self.draw.draw_rectangle((x0 + r + 1, y0, x1 - r - 1, y1), fill, 1)
-            if not full_x and not full_y:
-                left = [x0, y0, x0 + r, y1]
-                if corners[0]:
-                    left[1] += r + 1
-                if corners[3]:
-                    left[3] -= r + 1
-                self.draw.draw_rectangle(left, fill, 1)
-
-                right = [x1 - r, y0, x1, y1]
-                if corners[1]:
-                    right[1] += r + 1
-                if corners[2]:
-                    right[3] -= r + 1
-                self.draw.draw_rectangle(right, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            draw_corners(False)
-
-            if not full_x:
-                top = [x0, y0, x1, y0 + width - 1]
-                if corners[0]:
-                    top[0] += r + 1
-                if corners[1]:
-                    top[2] -= r + 1
-                self.draw.draw_rectangle(top, ink, 1)
-
-                bottom = [x0, y1 - width + 1, x1, y1]
-                if corners[3]:
-                    bottom[0] += r + 1
-                if corners[2]:
-                    bottom[2] -= r + 1
-                self.draw.draw_rectangle(bottom, ink, 1)
-            if not full_y:
-                left = [x0, y0, x0 + width - 1, y1]
-                if corners[0]:
-                    left[1] += r + 1
-                if corners[3]:
-                    left[3] -= r + 1
-                self.draw.draw_rectangle(left, ink, 1)
-
-                right = [x1 - width + 1, y0, x1, y1]
-                if corners[1]:
-                    right[1] += r + 1
-                if corners[2]:
-                    right[3] -= r + 1
-                self.draw.draw_rectangle(right, ink, 1)
-
-    def _multiline_check(self, text):
-        split_character = "\n" if isinstance(text, str) else b"\n"
-
-        return split_character in text
-
-    def _multiline_split(self, text):
-        split_character = "\n" if isinstance(text, str) else b"\n"
-
-        return text.split(split_character)
-
-    def _multiline_spacing(self, font, spacing, stroke_width):
-        return (
-            self.textbbox((0, 0), "A", font, stroke_width=stroke_width)[3]
-            + stroke_width
-            + spacing
-        )
-
-    def text(
-        self,
-        xy,
-        text,
-        fill=None,
-        font=None,
-        anchor=None,
-        spacing=4,
-        align="left",
-        direction=None,
-        features=None,
-        language=None,
-        stroke_width=0,
-        stroke_fill=None,
-        embedded_color=False,
-        *args,
-        **kwargs,
-    ):
-        """Draw text."""
-        if self._multiline_check(text):
-            return self.multiline_text(
-                xy,
-                text,
-                fill,
-                font,
-                anchor,
-                spacing,
-                align,
-                direction,
-                features,
-                language,
-                stroke_width,
-                stroke_fill,
-                embedded_color,
-            )
-
-        if embedded_color and self.mode not in ("RGB", "RGBA"):
-            msg = "Embedded color supported only in RGB and RGBA modes"
-            raise ValueError(msg)
-
-        if font is None:
-            font = self.getfont()
-
-        def getink(fill):
-            ink, fill = self._getink(fill)
-            if ink is None:
-                return fill
-            return ink
-
-        def draw_text(ink, stroke_width=0, stroke_offset=None):
-            mode = self.fontmode
-            if stroke_width == 0 and embedded_color:
-                mode = "RGBA"
-            coord = []
-            start = []
-            for i in range(2):
-                coord.append(int(xy[i]))
-                start.append(math.modf(xy[i])[0])
-            try:
-                mask, offset = font.getmask2(
-                    text,
-                    mode,
-                    direction=direction,
-                    features=features,
-                    language=language,
-                    stroke_width=stroke_width,
-                    anchor=anchor,
-                    ink=ink,
-                    start=start,
-                    *args,
-                    **kwargs,
-                )
-                coord = coord[0] + offset[0], coord[1] + offset[1]
-            except AttributeError:
-                try:
-                    mask = font.getmask(
-                        text,
-                        mode,
-                        direction,
-                        features,
-                        language,
-                        stroke_width,
-                        anchor,
-                        ink,
-                        start=start,
-                        *args,
-                        **kwargs,
-                    )
-                except TypeError:
-                    mask = font.getmask(text)
-            if stroke_offset:
-                coord = coord[0] + stroke_offset[0], coord[1] + stroke_offset[1]
-            if mode == "RGBA":
-                # font.getmask2(mode="RGBA") returns color in RGB bands and mask in A
-                # extract mask and set text alpha
-                color, mask = mask, mask.getband(3)
-                color.fillband(3, (ink >> 24) & 0xFF)
-                x, y = coord
-                self.im.paste(color, (x, y, x + mask.size[0], y + mask.size[1]), mask)
-            else:
-                self.draw.draw_bitmap(coord, mask, ink)
-
-        ink = getink(fill)
-        if ink is not None:
-            stroke_ink = None
-            if stroke_width:
-                stroke_ink = getink(stroke_fill) if stroke_fill is not None else ink
-
-            if stroke_ink is not None:
-                # Draw stroked text
-                draw_text(stroke_ink, stroke_width)
-
-                # Draw normal text
-                draw_text(ink, 0)
-            else:
-                # Only draw normal text
-                draw_text(ink)
-
-    def multiline_text(
-        self,
-        xy,
-        text,
-        fill=None,
-        font=None,
-        anchor=None,
-        spacing=4,
-        align="left",
-        direction=None,
-        features=None,
-        language=None,
-        stroke_width=0,
-        stroke_fill=None,
-        embedded_color=False,
-    ):
-        if direction == "ttb":
-            msg = "ttb direction is unsupported for multiline text"
-            raise ValueError(msg)
-
-        if anchor is None:
-            anchor = "la"
-        elif len(anchor) != 2:
-            msg = "anchor must be a 2 character string"
-            raise ValueError(msg)
-        elif anchor[1] in "tb":
-            msg = "anchor not supported for multiline text"
-            raise ValueError(msg)
-
-        widths = []
-        max_width = 0
-        lines = self._multiline_split(text)
-        line_spacing = self._multiline_spacing(font, spacing, stroke_width)
-        for line in lines:
-            line_width = self.textlength(
-                line, font, direction=direction, features=features, language=language
-            )
-            widths.append(line_width)
-            max_width = max(max_width, line_width)
-
-        top = xy[1]
-        if anchor[1] == "m":
-            top -= (len(lines) - 1) * line_spacing / 2.0
-        elif anchor[1] == "d":
-            top -= (len(lines) - 1) * line_spacing
-
-        for idx, line in enumerate(lines):
-            left = xy[0]
-            width_difference = max_width - widths[idx]
-
-            # first align left by anchor
-            if anchor[0] == "m":
-                left -= width_difference / 2.0
-            elif anchor[0] == "r":
-                left -= width_difference
-
-            # then align by align parameter
-            if align == "left":
-                pass
-            elif align == "center":
-                left += width_difference / 2.0
-            elif align == "right":
-                left += width_difference
-            else:
-                msg = 'align must be "left", "center" or "right"'
-                raise ValueError(msg)
-
-            self.text(
-                (left, top),
-                line,
-                fill,
-                font,
-                anchor,
-                direction=direction,
-                features=features,
-                language=language,
-                stroke_width=stroke_width,
-                stroke_fill=stroke_fill,
-                embedded_color=embedded_color,
-            )
-            top += line_spacing
-
-    def textlength(
-        self,
-        text,
-        font=None,
-        direction=None,
-        features=None,
-        language=None,
-        embedded_color=False,
-    ):
-        """Get the length of a given string, in pixels with 1/64 precision."""
-        if self._multiline_check(text):
-            msg = "can't measure length of multiline text"
-            raise ValueError(msg)
-        if embedded_color and self.mode not in ("RGB", "RGBA"):
-            msg = "Embedded color supported only in RGB and RGBA modes"
-            raise ValueError(msg)
-
-        if font is None:
-            font = self.getfont()
-        mode = "RGBA" if embedded_color else self.fontmode
-        return font.getlength(text, mode, direction, features, language)
-
-    def textbbox(
-        self,
-        xy,
-        text,
-        font=None,
-        anchor=None,
-        spacing=4,
-        align="left",
-        direction=None,
-        features=None,
-        language=None,
-        stroke_width=0,
-        embedded_color=False,
-    ):
-        """Get the bounding box of a given string, in pixels."""
-        if embedded_color and self.mode not in ("RGB", "RGBA"):
-            msg = "Embedded color supported only in RGB and RGBA modes"
-            raise ValueError(msg)
-
-        if self._multiline_check(text):
-            return self.multiline_textbbox(
-                xy,
-                text,
-                font,
-                anchor,
-                spacing,
-                align,
-                direction,
-                features,
-                language,
-                stroke_width,
-                embedded_color,
-            )
-
-        if font is None:
-            font = self.getfont()
-        mode = "RGBA" if embedded_color else self.fontmode
-        bbox = font.getbbox(
-            text, mode, direction, features, language, stroke_width, anchor
-        )
-        return bbox[0] + xy[0], bbox[1] + xy[1], bbox[2] + xy[0], bbox[3] + xy[1]
-
-    def multiline_textbbox(
-        self,
-        xy,
-        text,
-        font=None,
-        anchor=None,
-        spacing=4,
-        align="left",
-        direction=None,
-        features=None,
-        language=None,
-        stroke_width=0,
-        embedded_color=False,
-    ):
-        if direction == "ttb":
-            msg = "ttb direction is unsupported for multiline text"
-            raise ValueError(msg)
-
-        if anchor is None:
-            anchor = "la"
-        elif len(anchor) != 2:
-            msg = "anchor must be a 2 character string"
-            raise ValueError(msg)
-        elif anchor[1] in "tb":
-            msg = "anchor not supported for multiline text"
-            raise ValueError(msg)
-
-        widths = []
-        max_width = 0
-        lines = self._multiline_split(text)
-        line_spacing = self._multiline_spacing(font, spacing, stroke_width)
-        for line in lines:
-            line_width = self.textlength(
-                line,
-                font,
-                direction=direction,
-                features=features,
-                language=language,
-                embedded_color=embedded_color,
-            )
-            widths.append(line_width)
-            max_width = max(max_width, line_width)
-
-        top = xy[1]
-        if anchor[1] == "m":
-            top -= (len(lines) - 1) * line_spacing / 2.0
-        elif anchor[1] == "d":
-            top -= (len(lines) - 1) * line_spacing
-
-        bbox = None
-
-        for idx, line in enumerate(lines):
-            left = xy[0]
-            width_difference = max_width - widths[idx]
-
-            # first align left by anchor
-            if anchor[0] == "m":
-                left -= width_difference / 2.0
-            elif anchor[0] == "r":
-                left -= width_difference
-
-            # then align by align parameter
-            if align == "left":
-                pass
-            elif align == "center":
-                left += width_difference / 2.0
-            elif align == "right":
-                left += width_difference
-            else:
-                msg = 'align must be "left", "center" or "right"'
-                raise ValueError(msg)
-
-            bbox_line = self.textbbox(
-                (left, top),
-                line,
-                font,
-                anchor,
-                direction=direction,
-                features=features,
-                language=language,
-                stroke_width=stroke_width,
-                embedded_color=embedded_color,
-            )
-            if bbox is None:
-                bbox = bbox_line
-            else:
-                bbox = (
-                    min(bbox[0], bbox_line[0]),
-                    min(bbox[1], bbox_line[1]),
-                    max(bbox[2], bbox_line[2]),
-                    max(bbox[3], bbox_line[3]),
-                )
-
-            top += line_spacing
-
-        if bbox is None:
-            return xy[0], xy[1], xy[0], xy[1]
-        return bbox
-
-
-def Draw(im, mode=None):
-    """
-    A simple 2D drawing interface for PIL images.
-
-    :param im: The image to draw in.
-    :param mode: Optional mode to use for color values.  For RGB
-       images, this argument can be RGB or RGBA (to blend the
-       drawing into the image).  For all other modes, this argument
-       must be the same as the image mode.  If omitted, the mode
-       defaults to the mode of the image.
-    """
-    try:
-        return im.getdraw(mode)
-    except AttributeError:
-        return ImageDraw(im, mode)
-
-
-# experimental access to the outline API
-try:
-    Outline = Image.core.outline
-except AttributeError:
-    Outline = None
-
-
-def getdraw(im=None, hints=None):
-    """
-    (Experimental) A more advanced 2D drawing interface for PIL images,
-    based on the WCK interface.
-
-    :param im: The image to draw in.
-    :param hints: An optional list of hints.
-    :returns: A (drawing context, drawing resource factory) tuple.
-    """
-    # FIXME: this needs more work!
-    # FIXME: come up with a better 'hints' scheme.
-    handler = None
-    if not hints or "nicest" in hints:
-        try:
-            from . import _imagingagg as handler
-        except ImportError:
-            pass
-    if handler is None:
-        from . import ImageDraw2 as handler
-    if im:
-        im = handler.Draw(im)
-    return im, handler
-
-
-def floodfill(image, xy, value, border=None, thresh=0):
-    """
-    (experimental) Fills a bounded region with a given color.
-
-    :param image: Target image.
-    :param xy: Seed position (a 2-item coordinate tuple). See
-        :ref:`coordinate-system`.
-    :param value: Fill color.
-    :param border: Optional border value.  If given, the region consists of
-        pixels with a color different from the border color.  If not given,
-        the region consists of pixels having the same color as the seed
-        pixel.
-    :param thresh: Optional threshold value which specifies a maximum
-        tolerable difference of a pixel value from the 'background' in
-        order for it to be replaced. Useful for filling regions of
-        non-homogeneous, but similar, colors.
-    """
-    # based on an implementation by Eric S. Raymond
-    # amended by yo1995 @20180806
-    pixel = image.load()
-    x, y = xy
-    try:
-        background = pixel[x, y]
-        if _color_diff(value, background) <= thresh:
-            return  # seed point already has fill color
-        pixel[x, y] = value
-    except (ValueError, IndexError):
-        return  # seed point outside image
-    edge = {(x, y)}
-    # use a set to keep record of current and previous edge pixels
-    # to reduce memory consumption
-    full_edge = set()
-    while edge:
-        new_edge = set()
-        for x, y in edge:  # 4 adjacent method
-            for s, t in ((x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)):
-                # If already processed, or if a coordinate is negative, skip
-                if (s, t) in full_edge or s < 0 or t < 0:
-                    continue
-                try:
-                    p = pixel[s, t]
-                except (ValueError, IndexError):
-                    pass
-                else:
-                    full_edge.add((s, t))
-                    if border is None:
-                        fill = _color_diff(p, background) <= thresh
-                    else:
-                        fill = p != value and p != border
-                    if fill:
-                        pixel[s, t] = value
-                        new_edge.add((s, t))
-        full_edge = edge  # discard pixels processed
-        edge = new_edge
-
-
-def _compute_regular_polygon_vertices(bounding_circle, n_sides, rotation):
-    """
-    Generate a list of vertices for a 2D regular polygon.
-
-    :param bounding_circle: The bounding circle is a tuple defined
-        by a point and radius. The polygon is inscribed in this circle.
-        (e.g. ``bounding_circle=(x, y, r)`` or ``((x, y), r)``)
-    :param n_sides: Number of sides
-        (e.g. ``n_sides=3`` for a triangle, ``6`` for a hexagon)
-    :param rotation: Apply an arbitrary rotation to the polygon
-        (e.g. ``rotation=90``, applies a 90 degree rotation)
-    :return: List of regular polygon vertices
-        (e.g. ``[(25, 50), (50, 50), (50, 25), (25, 25)]``)
-
-    How are the vertices computed?
-    1. Compute the following variables
-        - theta: Angle between the apothem & the nearest polygon vertex
-        - side_length: Length of each polygon edge
-        - centroid: Center of bounding circle (1st, 2nd elements of bounding_circle)
-        - polygon_radius: Polygon radius (last element of bounding_circle)
-        - angles: Location of each polygon vertex in polar grid
-            (e.g. A square with 0 degree rotation => [225.0, 315.0, 45.0, 135.0])
-
-    2. For each angle in angles, get the polygon vertex at that angle
-        The vertex is computed using the equation below.
-            X= xcos(φ) + ysin(φ)
-            Y= −xsin(φ) + ycos(φ)
-
-        Note:
-            φ = angle in degrees
-            x = 0
-            y = polygon_radius
-
-        The formula above assumes rotation around the origin.
-        In our case, we are rotating around the centroid.
-        To account for this, we use the formula below
-            X = xcos(φ) + ysin(φ) + centroid_x
-            Y = −xsin(φ) + ycos(φ) + centroid_y
-    """
-    # 1. Error Handling
-    # 1.1 Check `n_sides` has an appropriate value
-    if not isinstance(n_sides, int):
-        msg = "n_sides should be an int"
-        raise TypeError(msg)
-    if n_sides < 3:
-        msg = "n_sides should be an int > 2"
-        raise ValueError(msg)
-
-    # 1.2 Check `bounding_circle` has an appropriate value
-    if not isinstance(bounding_circle, (list, tuple)):
-        msg = "bounding_circle should be a tuple"
-        raise TypeError(msg)
-
-    if len(bounding_circle) == 3:
-        *centroid, polygon_radius = bounding_circle
-    elif len(bounding_circle) == 2:
-        centroid, polygon_radius = bounding_circle
-    else:
-        msg = (
-            "bounding_circle should contain 2D coordinates "
-            "and a radius (e.g. (x, y, r) or ((x, y), r) )"
-        )
-        raise ValueError(msg)
-
-    if not all(isinstance(i, (int, float)) for i in (*centroid, polygon_radius)):
-        msg = "bounding_circle should only contain numeric data"
-        raise ValueError(msg)
-
-    if not len(centroid) == 2:
-        msg = "bounding_circle centre should contain 2D coordinates (e.g. (x, y))"
-        raise ValueError(msg)
-
-    if polygon_radius <= 0:
-        msg = "bounding_circle radius should be > 0"
-        raise ValueError(msg)
-
-    # 1.3 Check `rotation` has an appropriate value
-    if not isinstance(rotation, (int, float)):
-        msg = "rotation should be an int or float"
-        raise ValueError(msg)
-
-    # 2. Define Helper Functions
-    def _apply_rotation(point, degrees, centroid):
-        return (
-            round(
-                point[0] * math.cos(math.radians(360 - degrees))
-                - point[1] * math.sin(math.radians(360 - degrees))
-                + centroid[0],
-                2,
-            ),
-            round(
-                point[1] * math.cos(math.radians(360 - degrees))
-                + point[0] * math.sin(math.radians(360 - degrees))
-                + centroid[1],
-                2,
-            ),
-        )
-
-    def _compute_polygon_vertex(centroid, polygon_radius, angle):
-        start_point = [polygon_radius, 0]
-        return _apply_rotation(start_point, angle, centroid)
-
-    def _get_angles(n_sides, rotation):
-        angles = []
-        degrees = 360 / n_sides
-        # Start with the bottom left polygon vertex
-        current_angle = (270 - 0.5 * degrees) + rotation
-        for _ in range(0, n_sides):
-            angles.append(current_angle)
-            current_angle += degrees
-            if current_angle > 360:
-                current_angle -= 360
-        return angles
-
-    # 3. Variable Declarations
-    angles = _get_angles(n_sides, rotation)
-
-    # 4. Compute Vertices
-    return [
-        _compute_polygon_vertex(centroid, polygon_radius, angle) for angle in angles
-    ]
-
-
-def _color_diff(color1, color2):
-    """
-    Uses 1-norm distance to calculate difference between two values.
-    """
-    if isinstance(color2, tuple):
-        return sum(abs(color1[i] - color2[i]) for i in range(0, len(color2)))
-    else:
-        return abs(color1 - color2)
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/openapi/docs.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/openapi/docs.py
deleted file mode 100644
index 81f67dcc5bf59d32c7c8e59d5f345002d114a9ef..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/openapi/docs.py
+++ /dev/null
@@ -1,203 +0,0 @@
-import json
-from typing import Any, Dict, Optional
-
-from fastapi.encoders import jsonable_encoder
-from starlette.responses import HTMLResponse
-
-swagger_ui_default_parameters = {
-    "dom_id": "#swagger-ui",
-    "layout": "BaseLayout",
-    "deepLinking": True,
-    "showExtensions": True,
-    "showCommonExtensions": True,
-}
-
-
-def get_swagger_ui_html(
-    *,
-    openapi_url: str,
-    title: str,
-    swagger_js_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js",
-    swagger_css_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css",
-    swagger_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
-    oauth2_redirect_url: Optional[str] = None,
-    init_oauth: Optional[Dict[str, Any]] = None,
-    swagger_ui_parameters: Optional[Dict[str, Any]] = None,
-) -> HTMLResponse:
-    current_swagger_ui_parameters = swagger_ui_default_parameters.copy()
-    if swagger_ui_parameters:
-        current_swagger_ui_parameters.update(swagger_ui_parameters)
-
-    html = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-    <link type="text/css" rel="stylesheet" href="{swagger_css_url}">
-    <link rel="shortcut icon" href="{swagger_favicon_url}">
-    <title>{title}</title>
-    </head>
-    <body>
-    <div id="swagger-ui">
-    </div>
-    <script src="{swagger_js_url}"></script>
-    <!-- `SwaggerUIBundle` is now available on the page -->
-    <script>
-    const ui = SwaggerUIBundle({{
-        url: '{openapi_url}',
-    """
-
-    for key, value in current_swagger_ui_parameters.items():
-        html += f"{json.dumps(key)}: {json.dumps(jsonable_encoder(value))},\n"
-
-    if oauth2_redirect_url:
-        html += f"oauth2RedirectUrl: window.location.origin + '{oauth2_redirect_url}',"
-
-    html += """
-    presets: [
-        SwaggerUIBundle.presets.apis,
-        SwaggerUIBundle.SwaggerUIStandalonePreset
-        ],
-    })"""
-
-    if init_oauth:
-        html += f"""
-        ui.initOAuth({json.dumps(jsonable_encoder(init_oauth))})
-        """
-
-    html += """
-    </script>
-    </body>
-    </html>
-    """
-    return HTMLResponse(html)
-
-
-def get_redoc_html(
-    *,
-    openapi_url: str,
-    title: str,
-    redoc_js_url: str = "https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js",
-    redoc_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
-    with_google_fonts: bool = True,
-) -> HTMLResponse:
-    html = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-    <title>{title}</title>
-    <!-- needed for adaptive design -->
-    <meta charset="utf-8"/>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    """
-    if with_google_fonts:
-        html += """
-    <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
-    """
-    html += f"""
-    <link rel="shortcut icon" href="{redoc_favicon_url}">
-    <!--
-    ReDoc doesn't change outer page styles
-    -->
-    <style>
-      body {{
-        margin: 0;
-        padding: 0;
-      }}
-    </style>
-    </head>
-    <body>
-    <noscript>
-        ReDoc requires Javascript to function. Please enable it to browse the documentation.
-    </noscript>
-    <redoc spec-url="{openapi_url}"></redoc>
-    <script src="{redoc_js_url}"> </script>
-    </body>
-    </html>
-    """
-    return HTMLResponse(html)
-
-
-def get_swagger_ui_oauth2_redirect_html() -> HTMLResponse:
-    # copied from https://github.com/swagger-api/swagger-ui/blob/v4.14.0/dist/oauth2-redirect.html
-    html = """
-    <!doctype html>
-    <html lang="en-US">
-    <head>
-        <title>Swagger UI: OAuth2 Redirect</title>
-    </head>
-    <body>
-    <script>
-        'use strict';
-        function run () {
-            var oauth2 = window.opener.swaggerUIRedirectOauth2;
-            var sentState = oauth2.state;
-            var redirectUrl = oauth2.redirectUrl;
-            var isValid, qp, arr;
-
-            if (/code|token|error/.test(window.location.hash)) {
-                qp = window.location.hash.substring(1).replace('?', '&');
-            } else {
-                qp = location.search.substring(1);
-            }
-
-            arr = qp.split("&");
-            arr.forEach(function (v,i,_arr) { _arr[i] = '"' + v.replace('=', '":"') + '"';});
-            qp = qp ? JSON.parse('{' + arr.join() + '}',
-                    function (key, value) {
-                        return key === "" ? value : decodeURIComponent(value);
-                    }
-            ) : {};
-
-            isValid = qp.state === sentState;
-
-            if ((
-              oauth2.auth.schema.get("flow") === "accessCode" ||
-              oauth2.auth.schema.get("flow") === "authorizationCode" ||
-              oauth2.auth.schema.get("flow") === "authorization_code"
-            ) && !oauth2.auth.code) {
-                if (!isValid) {
-                    oauth2.errCb({
-                        authId: oauth2.auth.name,
-                        source: "auth",
-                        level: "warning",
-                        message: "Authorization may be unsafe, passed state was changed in server. The passed state wasn't returned from auth server."
-                    });
-                }
-
-                if (qp.code) {
-                    delete oauth2.state;
-                    oauth2.auth.code = qp.code;
-                    oauth2.callback({auth: oauth2.auth, redirectUrl: redirectUrl});
-                } else {
-                    let oauthErrorMsg;
-                    if (qp.error) {
-                        oauthErrorMsg = "["+qp.error+"]: " +
-                            (qp.error_description ? qp.error_description+ ". " : "no accessCode received from the server. ") +
-                            (qp.error_uri ? "More info: "+qp.error_uri : "");
-                    }
-
-                    oauth2.errCb({
-                        authId: oauth2.auth.name,
-                        source: "auth",
-                        level: "error",
-                        message: oauthErrorMsg || "[Authorization failed]: no accessCode received from the server."
-                    });
-                }
-            } else {
-                oauth2.callback({auth: oauth2.auth, token: qp, isValid: isValid, redirectUrl: redirectUrl});
-            }
-            window.close();
-        }
-
-        if (document.readyState !== 'loading') {
-            run();
-        } else {
-            document.addEventListener('DOMContentLoaded', function () {
-                run();
-            });
-        }
-    </script>
-    </body>
-    </html>
-        """
-    return HTMLResponse(content=html)
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/designspaceLib/statNames.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/designspaceLib/statNames.py
deleted file mode 100644
index a164169da69e17d4febdc82e0e50d48191ac533d..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/designspaceLib/statNames.py
+++ /dev/null
@@ -1,252 +0,0 @@
-"""Compute name information for a given location in user-space coordinates
-using STAT data. This can be used to fill-in automatically the names of an
-instance:
-
-.. code:: python
-
-    instance = doc.instances[0]
-    names = getStatNames(doc, instance.getFullUserLocation(doc))
-    print(names.styleNames)
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple, Union
-import logging
-
-from fontTools.designspaceLib import (
-    AxisDescriptor,
-    AxisLabelDescriptor,
-    DesignSpaceDocument,
-    DesignSpaceDocumentError,
-    DiscreteAxisDescriptor,
-    SimpleLocationDict,
-    SourceDescriptor,
-)
-
-LOGGER = logging.getLogger(__name__)
-
-# TODO(Python 3.8): use Literal
-# RibbiStyleName = Union[Literal["regular"], Literal["bold"], Literal["italic"], Literal["bold italic"]]
-RibbiStyle = str
-BOLD_ITALIC_TO_RIBBI_STYLE = {
-    (False, False): "regular",
-    (False, True): "italic",
-    (True, False): "bold",
-    (True, True): "bold italic",
-}
-
-
-@dataclass
-class StatNames:
-    """Name data generated from the STAT table information."""
-
-    familyNames: Dict[str, str]
-    styleNames: Dict[str, str]
-    postScriptFontName: Optional[str]
-    styleMapFamilyNames: Dict[str, str]
-    styleMapStyleName: Optional[RibbiStyle]
-
-
-def getStatNames(
-    doc: DesignSpaceDocument, userLocation: SimpleLocationDict
-) -> StatNames:
-    """Compute the family, style, PostScript names of the given ``userLocation``
-    using the document's STAT information.
-
-    Also computes localizations.
-
-    If not enough STAT data is available for a given name, either its dict of
-    localized names will be empty (family and style names), or the name will be
-    None (PostScript name).
-
-    .. versionadded:: 5.0
-    """
-    familyNames: Dict[str, str] = {}
-    defaultSource: Optional[SourceDescriptor] = doc.findDefault()
-    if defaultSource is None:
-        LOGGER.warning("Cannot determine default source to look up family name.")
-    elif defaultSource.familyName is None:
-        LOGGER.warning(
-            "Cannot look up family name, assign the 'familyname' attribute to the default source."
-        )
-    else:
-        familyNames = {
-            "en": defaultSource.familyName,
-            **defaultSource.localisedFamilyName,
-        }
-
-    styleNames: Dict[str, str] = {}
-    # If a free-standing label matches the location, use it for name generation.
-    label = doc.labelForUserLocation(userLocation)
-    if label is not None:
-        styleNames = {"en": label.name, **label.labelNames}
-    # Otherwise, scour the axis labels for matches.
-    else:
-        # Gather all languages in which at least one translation is provided
-        # Then build names for all these languages, but fallback to English
-        # whenever a translation is missing.
-        labels = _getAxisLabelsForUserLocation(doc.axes, userLocation)
-        if labels:
-            languages = set(
-                language for label in labels for language in label.labelNames
-            )
-            languages.add("en")
-            for language in languages:
-                styleName = " ".join(
-                    label.labelNames.get(language, label.defaultName)
-                    for label in labels
-                    if not label.elidable
-                )
-                if not styleName and doc.elidedFallbackName is not None:
-                    styleName = doc.elidedFallbackName
-                styleNames[language] = styleName
-
-    if "en" not in familyNames or "en" not in styleNames:
-        # Not enough information to compute PS names of styleMap names
-        return StatNames(
-            familyNames=familyNames,
-            styleNames=styleNames,
-            postScriptFontName=None,
-            styleMapFamilyNames={},
-            styleMapStyleName=None,
-        )
-
-    postScriptFontName = f"{familyNames['en']}-{styleNames['en']}".replace(" ", "")
-
-    styleMapStyleName, regularUserLocation = _getRibbiStyle(doc, userLocation)
-
-    styleNamesForStyleMap = styleNames
-    if regularUserLocation != userLocation:
-        regularStatNames = getStatNames(doc, regularUserLocation)
-        styleNamesForStyleMap = regularStatNames.styleNames
-
-    styleMapFamilyNames = {}
-    for language in set(familyNames).union(styleNames.keys()):
-        familyName = familyNames.get(language, familyNames["en"])
-        styleName = styleNamesForStyleMap.get(language, styleNamesForStyleMap["en"])
-        styleMapFamilyNames[language] = (familyName + " " + styleName).strip()
-
-    return StatNames(
-        familyNames=familyNames,
-        styleNames=styleNames,
-        postScriptFontName=postScriptFontName,
-        styleMapFamilyNames=styleMapFamilyNames,
-        styleMapStyleName=styleMapStyleName,
-    )
-
-
-def _getSortedAxisLabels(
-    axes: list[Union[AxisDescriptor, DiscreteAxisDescriptor]],
-) -> Dict[str, list[AxisLabelDescriptor]]:
-    """Returns axis labels sorted by their ordering, with unordered ones appended as
-    they are listed."""
-
-    # First, get the axis labels with explicit ordering...
-    sortedAxes = sorted(
-        (axis for axis in axes if axis.axisOrdering is not None),
-        key=lambda a: a.axisOrdering,
-    )
-    sortedLabels: Dict[str, list[AxisLabelDescriptor]] = {
-        axis.name: axis.axisLabels for axis in sortedAxes
-    }
-
-    # ... then append the others in the order they appear.
-    # NOTE: This relies on Python 3.7+ dict's preserved insertion order.
-    for axis in axes:
-        if axis.axisOrdering is None:
-            sortedLabels[axis.name] = axis.axisLabels
-
-    return sortedLabels
-
-
-def _getAxisLabelsForUserLocation(
-    axes: list[Union[AxisDescriptor, DiscreteAxisDescriptor]],
-    userLocation: SimpleLocationDict,
-) -> list[AxisLabelDescriptor]:
-    labels: list[AxisLabelDescriptor] = []
-
-    allAxisLabels = _getSortedAxisLabels(axes)
-    if allAxisLabels.keys() != userLocation.keys():
-        LOGGER.warning(
-            f"Mismatch between user location '{userLocation.keys()}' and available "
-            f"labels for '{allAxisLabels.keys()}'."
-        )
-
-    for axisName, axisLabels in allAxisLabels.items():
-        userValue = userLocation[axisName]
-        label: Optional[AxisLabelDescriptor] = next(
-            (
-                l
-                for l in axisLabels
-                if l.userValue == userValue
-                or (
-                    l.userMinimum is not None
-                    and l.userMaximum is not None
-                    and l.userMinimum <= userValue <= l.userMaximum
-                )
-            ),
-            None,
-        )
-        if label is None:
-            LOGGER.debug(
-                f"Document needs a label for axis '{axisName}', user value '{userValue}'."
-            )
-        else:
-            labels.append(label)
-
-    return labels
-
-
-def _getRibbiStyle(
-    self: DesignSpaceDocument, userLocation: SimpleLocationDict
-) -> Tuple[RibbiStyle, SimpleLocationDict]:
-    """Compute the RIBBI style name of the given user location,
-    return the location of the matching Regular in the RIBBI group.
-
-    .. versionadded:: 5.0
-    """
-    regularUserLocation = {}
-    axes_by_tag = {axis.tag: axis for axis in self.axes}
-
-    bold: bool = False
-    italic: bool = False
-
-    axis = axes_by_tag.get("wght")
-    if axis is not None:
-        for regular_label in axis.axisLabels:
-            if (
-                regular_label.linkedUserValue == userLocation[axis.name]
-                # In the "recursive" case where both the Regular has
-                # linkedUserValue pointing the Bold, and the Bold has
-                # linkedUserValue pointing to the Regular, only consider the
-                # first case: Regular (e.g. 400) has linkedUserValue pointing to
-                # Bold (e.g. 700, higher than Regular)
-                and regular_label.userValue < regular_label.linkedUserValue
-            ):
-                regularUserLocation[axis.name] = regular_label.userValue
-                bold = True
-                break
-
-    axis = axes_by_tag.get("ital") or axes_by_tag.get("slnt")
-    if axis is not None:
-        for upright_label in axis.axisLabels:
-            if (
-                upright_label.linkedUserValue == userLocation[axis.name]
-                # In the "recursive" case where both the Upright has
-                # linkedUserValue pointing the Italic, and the Italic has
-                # linkedUserValue pointing to the Upright, only consider the
-                # first case: Upright (e.g. ital=0, slant=0) has
-                # linkedUserValue pointing to Italic (e.g ital=1, slant=-12 or
-                # slant=12 for backwards italics, in any case higher than
-                # Upright in absolute value, hence the abs() below.
-                and abs(upright_label.userValue) < abs(upright_label.linkedUserValue)
-            ):
-                regularUserLocation[axis.name] = upright_label.userValue
-                italic = True
-                break
-
-    return BOLD_ITALIC_TO_RIBBI_STYLE[bold, italic], {
-        **userLocation,
-        **regularUserLocation,
-    }
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/flagging.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/flagging.py
deleted file mode 100644
index c98828825e74e8146bb4c4075e107c0f928de2b0..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/flagging.py
+++ /dev/null
@@ -1,518 +0,0 @@
-from __future__ import annotations
-
-import csv
-import datetime
-import json
-import os
-import time
-import uuid
-from abc import ABC, abstractmethod
-from collections import OrderedDict
-from distutils.version import StrictVersion
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-import filelock
-import huggingface_hub
-import pkg_resources
-from gradio_client import utils as client_utils
-from gradio_client.documentation import document, set_documentation_group
-
-import gradio as gr
-from gradio import utils
-from gradio.deprecation import warn_deprecation
-
-if TYPE_CHECKING:
-    from gradio.components import IOComponent
-
-set_documentation_group("flagging")
-
-
-class FlaggingCallback(ABC):
-    """
-    An abstract class for defining the methods that any FlaggingCallback should have.
-    """
-
-    @abstractmethod
-    def setup(self, components: list[IOComponent], flagging_dir: str):
-        """
-        This method should be overridden and ensure that everything is set up correctly for flag().
-        This method gets called once at the beginning of the Interface.launch() method.
-        Parameters:
-        components: Set of components that will provide flagged data.
-        flagging_dir: A string, typically containing the path to the directory where the flagging file should be storied (provided as an argument to Interface.__init__()).
-        """
-        pass
-
-    @abstractmethod
-    def flag(
-        self,
-        flag_data: list[Any],
-        flag_option: str = "",
-        username: str | None = None,
-    ) -> int:
-        """
-        This method should be overridden by the FlaggingCallback subclass and may contain optional additional arguments.
-        This gets called every time the <flag> button is pressed.
-        Parameters:
-        interface: The Interface object that is being used to launch the flagging interface.
-        flag_data: The data to be flagged.
-        flag_option (optional): In the case that flagging_options are provided, the flag option that is being used.
-        username (optional): The username of the user that is flagging the data, if logged in.
-        Returns:
-        (int) The total number of samples that have been flagged.
-        """
-        pass
-
-
-@document()
-class SimpleCSVLogger(FlaggingCallback):
-    """
-    A simplified implementation of the FlaggingCallback abstract class
-    provided for illustrative purposes.  Each flagged sample (both the input and output data)
-    is logged to a CSV file on the machine running the gradio app.
-    Example:
-        import gradio as gr
-        def image_classifier(inp):
-            return {'cat': 0.3, 'dog': 0.7}
-        demo = gr.Interface(fn=image_classifier, inputs="image", outputs="label",
-                            flagging_callback=SimpleCSVLogger())
-    """
-
-    def __init__(self):
-        pass
-
-    def setup(self, components: list[IOComponent], flagging_dir: str | Path):
-        self.components = components
-        self.flagging_dir = flagging_dir
-        os.makedirs(flagging_dir, exist_ok=True)
-
-    def flag(
-        self,
-        flag_data: list[Any],
-        flag_option: str = "",
-        username: str | None = None,
-    ) -> int:
-        flagging_dir = self.flagging_dir
-        log_filepath = Path(flagging_dir) / "log.csv"
-
-        csv_data = []
-        for component, sample in zip(self.components, flag_data):
-            save_dir = Path(
-                flagging_dir
-            ) / client_utils.strip_invalid_filename_characters(component.label or "")
-            csv_data.append(
-                component.deserialize(
-                    sample,
-                    save_dir,
-                    None,
-                )
-            )
-
-        with open(log_filepath, "a", newline="") as csvfile:
-            writer = csv.writer(csvfile)
-            writer.writerow(utils.sanitize_list_for_csv(csv_data))
-
-        with open(log_filepath) as csvfile:
-            line_count = len(list(csv.reader(csvfile))) - 1
-        return line_count
-
-
-@document()
-class CSVLogger(FlaggingCallback):
-    """
-    The default implementation of the FlaggingCallback abstract class. Each flagged
-    sample (both the input and output data) is logged to a CSV file with headers on the machine running the gradio app.
-    Example:
-        import gradio as gr
-        def image_classifier(inp):
-            return {'cat': 0.3, 'dog': 0.7}
-        demo = gr.Interface(fn=image_classifier, inputs="image", outputs="label",
-                            flagging_callback=CSVLogger())
-    Guides: using-flagging
-    """
-
-    def __init__(self):
-        pass
-
-    def setup(
-        self,
-        components: list[IOComponent],
-        flagging_dir: str | Path,
-    ):
-        self.components = components
-        self.flagging_dir = flagging_dir
-        os.makedirs(flagging_dir, exist_ok=True)
-
-    def flag(
-        self,
-        flag_data: list[Any],
-        flag_option: str = "",
-        username: str | None = None,
-    ) -> int:
-        flagging_dir = self.flagging_dir
-        log_filepath = Path(flagging_dir) / "log.csv"
-        is_new = not Path(log_filepath).exists()
-        headers = [
-            getattr(component, "label", None) or f"component {idx}"
-            for idx, component in enumerate(self.components)
-        ] + [
-            "flag",
-            "username",
-            "timestamp",
-        ]
-
-        csv_data = []
-        for idx, (component, sample) in enumerate(zip(self.components, flag_data)):
-            save_dir = Path(
-                flagging_dir
-            ) / client_utils.strip_invalid_filename_characters(
-                getattr(component, "label", None) or f"component {idx}"
-            )
-            if utils.is_update(sample):
-                csv_data.append(str(sample))
-            else:
-                csv_data.append(
-                    component.deserialize(sample, save_dir=save_dir)
-                    if sample is not None
-                    else ""
-                )
-        csv_data.append(flag_option)
-        csv_data.append(username if username is not None else "")
-        csv_data.append(str(datetime.datetime.now()))
-
-        with open(log_filepath, "a", newline="", encoding="utf-8") as csvfile:
-            writer = csv.writer(csvfile)
-            if is_new:
-                writer.writerow(utils.sanitize_list_for_csv(headers))
-            writer.writerow(utils.sanitize_list_for_csv(csv_data))
-
-        with open(log_filepath, encoding="utf-8") as csvfile:
-            line_count = len(list(csv.reader(csvfile))) - 1
-        return line_count
-
-
-@document()
-class HuggingFaceDatasetSaver(FlaggingCallback):
-    """
-    A callback that saves each flagged sample (both the input and output data) to a HuggingFace dataset.
-
-    Example:
-        import gradio as gr
-        hf_writer = gr.HuggingFaceDatasetSaver(HF_API_TOKEN, "image-classification-mistakes")
-        def image_classifier(inp):
-            return {'cat': 0.3, 'dog': 0.7}
-        demo = gr.Interface(fn=image_classifier, inputs="image", outputs="label",
-                            allow_flagging="manual", flagging_callback=hf_writer)
-    Guides: using-flagging
-    """
-
-    def __init__(
-        self,
-        hf_token: str,
-        dataset_name: str,
-        organization: str | None = None,
-        private: bool = False,
-        info_filename: str = "dataset_info.json",
-        separate_dirs: bool = False,
-        verbose: bool = True,  # silently ignored. TODO: remove it?
-    ):
-        """
-        Parameters:
-            hf_token: The HuggingFace token to use to create (and write the flagged sample to) the HuggingFace dataset (defaults to the registered one).
-            dataset_name: The repo_id of the dataset to save the data to, e.g. "image-classifier-1" or "username/image-classifier-1".
-            organization: Deprecated argument. Please pass a full dataset id (e.g. 'username/dataset_name') to `dataset_name` instead.
-            private: Whether the dataset should be private (defaults to False).
-            info_filename: The name of the file to save the dataset info (defaults to "dataset_infos.json").
-            separate_dirs: If True, each flagged item will be saved in a separate directory. This makes the flagging more robust to concurrent editing, but may be less convenient to use.
-        """
-        if organization is not None:
-            warn_deprecation(
-                "Parameter `organization` is not used anymore. Please pass a full dataset id (e.g. 'username/dataset_name') to `dataset_name` instead."
-            )
-        self.hf_token = hf_token
-        self.dataset_id = dataset_name  # TODO: rename parameter (but ensure backward compatibility somehow)
-        self.dataset_private = private
-        self.info_filename = info_filename
-        self.separate_dirs = separate_dirs
-
-    def setup(self, components: list[IOComponent], flagging_dir: str):
-        """
-        Params:
-        flagging_dir (str): local directory where the dataset is cloned,
-        updated, and pushed from.
-        """
-        hh_version = pkg_resources.get_distribution("huggingface_hub").version
-        try:
-            if StrictVersion(hh_version) < StrictVersion("0.12.0"):
-                raise ImportError(
-                    "The `huggingface_hub` package must be version 0.12.0 or higher"
-                    "for HuggingFaceDatasetSaver. Try 'pip install huggingface_hub --upgrade'."
-                )
-        except ValueError:
-            pass
-
-        # Setup dataset on the Hub
-        self.dataset_id = huggingface_hub.create_repo(
-            repo_id=self.dataset_id,
-            token=self.hf_token,
-            private=self.dataset_private,
-            repo_type="dataset",
-            exist_ok=True,
-        ).repo_id
-
-        # Setup flagging dir
-        self.components = components
-        self.dataset_dir = (
-            Path(flagging_dir).absolute() / self.dataset_id.split("/")[-1]
-        )
-        self.dataset_dir.mkdir(parents=True, exist_ok=True)
-        self.infos_file = self.dataset_dir / self.info_filename
-
-        # Download remote files to local
-        remote_files = [self.info_filename]
-        if not self.separate_dirs:
-            # No separate dirs => means all data is in the same CSV file => download it to get its current content
-            remote_files.append("data.csv")
-
-        for filename in remote_files:
-            try:
-                huggingface_hub.hf_hub_download(
-                    repo_id=self.dataset_id,
-                    repo_type="dataset",
-                    filename=filename,
-                    local_dir=self.dataset_dir,
-                    token=self.hf_token,
-                )
-            except huggingface_hub.utils.EntryNotFoundError:
-                pass
-
-    def flag(
-        self,
-        flag_data: list[Any],
-        flag_option: str = "",
-        username: str | None = None,
-    ) -> int:
-        if self.separate_dirs:
-            # JSONL files to support dataset preview on the Hub
-            unique_id = str(uuid.uuid4())
-            components_dir = self.dataset_dir / str(uuid.uuid4())
-            data_file = components_dir / "metadata.jsonl"
-            path_in_repo = unique_id  # upload in sub folder (safer for concurrency)
-        else:
-            # Unique CSV file
-            components_dir = self.dataset_dir
-            data_file = components_dir / "data.csv"
-            path_in_repo = None  # upload at root level
-
-        return self._flag_in_dir(
-            data_file=data_file,
-            components_dir=components_dir,
-            path_in_repo=path_in_repo,
-            flag_data=flag_data,
-            flag_option=flag_option,
-            username=username or "",
-        )
-
-    def _flag_in_dir(
-        self,
-        data_file: Path,
-        components_dir: Path,
-        path_in_repo: str | None,
-        flag_data: list[Any],
-        flag_option: str = "",
-        username: str = "",
-    ) -> int:
-        # Deserialize components (write images/audio to files)
-        features, row = self._deserialize_components(
-            components_dir, flag_data, flag_option, username
-        )
-
-        # Write generic info to dataset_infos.json + upload
-        with filelock.FileLock(str(self.infos_file) + ".lock"):
-            if not self.infos_file.exists():
-                self.infos_file.write_text(
-                    json.dumps({"flagged": {"features": features}})
-                )
-
-                huggingface_hub.upload_file(
-                    repo_id=self.dataset_id,
-                    repo_type="dataset",
-                    token=self.hf_token,
-                    path_in_repo=self.infos_file.name,
-                    path_or_fileobj=self.infos_file,
-                )
-
-        headers = list(features.keys())
-
-        if not self.separate_dirs:
-            with filelock.FileLock(components_dir / ".lock"):
-                sample_nb = self._save_as_csv(data_file, headers=headers, row=row)
-                sample_name = str(sample_nb)
-                huggingface_hub.upload_folder(
-                    repo_id=self.dataset_id,
-                    repo_type="dataset",
-                    commit_message=f"Flagged sample #{sample_name}",
-                    path_in_repo=path_in_repo,
-                    ignore_patterns="*.lock",
-                    folder_path=components_dir,
-                    token=self.hf_token,
-                )
-        else:
-            sample_name = self._save_as_jsonl(data_file, headers=headers, row=row)
-            sample_nb = len(
-                [path for path in self.dataset_dir.iterdir() if path.is_dir()]
-            )
-            huggingface_hub.upload_folder(
-                repo_id=self.dataset_id,
-                repo_type="dataset",
-                commit_message=f"Flagged sample #{sample_name}",
-                path_in_repo=path_in_repo,
-                ignore_patterns="*.lock",
-                folder_path=components_dir,
-                token=self.hf_token,
-            )
-
-        return sample_nb
-
-    @staticmethod
-    def _save_as_csv(data_file: Path, headers: list[str], row: list[Any]) -> int:
-        """Save data as CSV and return the sample name (row number)."""
-        is_new = not data_file.exists()
-
-        with data_file.open("a", newline="", encoding="utf-8") as csvfile:
-            writer = csv.writer(csvfile)
-
-            # Write CSV headers if new file
-            if is_new:
-                writer.writerow(utils.sanitize_list_for_csv(headers))
-
-            # Write CSV row for flagged sample
-            writer.writerow(utils.sanitize_list_for_csv(row))
-
-        with data_file.open(encoding="utf-8") as csvfile:
-            return sum(1 for _ in csv.reader(csvfile)) - 1
-
-    @staticmethod
-    def _save_as_jsonl(data_file: Path, headers: list[str], row: list[Any]) -> str:
-        """Save data as JSONL and return the sample name (uuid)."""
-        Path.mkdir(data_file.parent, parents=True, exist_ok=True)
-        with open(data_file, "w") as f:
-            json.dump(dict(zip(headers, row)), f)
-        return data_file.parent.name
-
-    def _deserialize_components(
-        self,
-        data_dir: Path,
-        flag_data: list[Any],
-        flag_option: str = "",
-        username: str = "",
-    ) -> tuple[dict[Any, Any], list[Any]]:
-        """Deserialize components and return the corresponding row for the flagged sample.
-
-        Images/audio are saved to disk as individual files.
-        """
-        # Components that can have a preview on dataset repos
-        file_preview_types = {gr.Audio: "Audio", gr.Image: "Image"}
-
-        # Generate the row corresponding to the flagged sample
-        features = OrderedDict()
-        row = []
-        for component, sample in zip(self.components, flag_data):
-            # Get deserialized object (will save sample to disk if applicable -file, audio, image,...-)
-            label = component.label or ""
-            save_dir = data_dir / client_utils.strip_invalid_filename_characters(label)
-            deserialized = component.deserialize(sample, save_dir, None)
-
-            # Add deserialized object to row
-            features[label] = {"dtype": "string", "_type": "Value"}
-            try:
-                assert Path(deserialized).exists()
-                row.append(Path(deserialized).name)
-            except (AssertionError, TypeError, ValueError):
-                row.append(str(deserialized))
-
-            # If component is eligible for a preview, add the URL of the file
-            if isinstance(component, tuple(file_preview_types)):  # type: ignore
-                for _component, _type in file_preview_types.items():
-                    if isinstance(component, _component):
-                        features[label + " file"] = {"_type": _type}
-                        break
-                path_in_repo = str(  # returned filepath is absolute, we want it relative to compute URL
-                    Path(deserialized).relative_to(self.dataset_dir)
-                ).replace(
-                    "\\", "/"
-                )
-                row.append(
-                    huggingface_hub.hf_hub_url(
-                        repo_id=self.dataset_id,
-                        filename=path_in_repo,
-                        repo_type="dataset",
-                    )
-                )
-        features["flag"] = {"dtype": "string", "_type": "Value"}
-        features["username"] = {"dtype": "string", "_type": "Value"}
-        row.append(flag_option)
-        row.append(username)
-        return features, row
-
-
-class HuggingFaceDatasetJSONSaver(HuggingFaceDatasetSaver):
-    def __init__(
-        self,
-        hf_token: str,
-        dataset_name: str,
-        organization: str | None = None,
-        private: bool = False,
-        info_filename: str = "dataset_info.json",
-        verbose: bool = True,  # silently ignored. TODO: remove it?
-    ):
-        warn_deprecation(
-            "Callback `HuggingFaceDatasetJSONSaver` is deprecated in favor of using"
-            " `HuggingFaceDatasetSaver` and passing `separate_dirs=True` as parameter."
-        )
-        super().__init__(
-            hf_token=hf_token,
-            dataset_name=dataset_name,
-            organization=organization,
-            private=private,
-            info_filename=info_filename,
-            separate_dirs=True,
-        )
-
-
-class FlagMethod:
-    """
-    Helper class that contains the flagging options and calls the flagging method. Also
-    provides visual feedback to the user when flag is clicked.
-    """
-
-    def __init__(
-        self,
-        flagging_callback: FlaggingCallback,
-        label: str,
-        value: str,
-        visual_feedback: bool = True,
-    ):
-        self.flagging_callback = flagging_callback
-        self.label = label
-        self.value = value
-        self.__name__ = "Flag"
-        self.visual_feedback = visual_feedback
-
-    def __call__(self, request: gr.Request, *flag_data):
-        try:
-            self.flagging_callback.flag(
-                list(flag_data), flag_option=self.value, username=request.username
-            )
-        except Exception as e:
-            print(f"Error while flagging: {e}")
-            if self.visual_feedback:
-                return "Error!"
-        if not self.visual_feedback:
-            return
-        time.sleep(0.8)  # to provide enough time for the user to observe button change
-        return self.reset()
-
-    def reset(self):
-        return gr.Button.update(value=self.label, interactive=True)
diff --git a/spaces/Datasculptor/DescriptionGPT/app.py b/spaces/Datasculptor/DescriptionGPT/app.py
deleted file mode 100644
index 2fbf652fa6f5798f1903f39d7fd51494c336d2d0..0000000000000000000000000000000000000000
--- a/spaces/Datasculptor/DescriptionGPT/app.py
+++ /dev/null
@@ -1,160 +0,0 @@
-import os
-from pyChatGPT import ChatGPT
-
-os.system("pip install -U gradio")
-
-import sys
-import gradio as gr
-
-os.system(
-    "pip install detectron2 -f https://dl.fbaipublicfiles.com/detectron2/wheels/cu102/torch1.9/index.html"
-)
-
-# clone and install Detic
-os.system(
-    "git clone https://github.com/facebookresearch/Detic.git --recurse-submodules"
-)
-os.chdir("Detic")
-
-# Install detectron2
-import torch
-
-# Some basic setup:
-# Setup detectron2 logger
-import detectron2
-from detectron2.utils.logger import setup_logger
-
-setup_logger()
-
-# import some common libraries
-import sys
-import numpy as np
-import os, json, cv2, random
-
-# import some common detectron2 utilities
-from detectron2 import model_zoo
-from detectron2.engine import DefaultPredictor
-from detectron2.config import get_cfg
-from detectron2.utils.visualizer import Visualizer
-from detectron2.data import MetadataCatalog, DatasetCatalog
-
-# Detic libraries
-sys.path.insert(0, "third_party/CenterNet2/projects/CenterNet2/")
-sys.path.insert(0, "third_party/CenterNet2/")
-from centernet.config import add_centernet_config
-from detic.config import add_detic_config
-from detic.modeling.utils import reset_cls_test
-
-from PIL import Image
-
-# Build the detector and download our pretrained weights
-cfg = get_cfg()
-add_centernet_config(cfg)
-add_detic_config(cfg)
-cfg.MODEL.DEVICE = "cpu"
-cfg.merge_from_file("configs/Detic_LCOCOI21k_CLIP_SwinB_896b32_4x_ft4x_max-size.yaml")
-cfg.MODEL.WEIGHTS = "https://dl.fbaipublicfiles.com/detic/Detic_LCOCOI21k_CLIP_SwinB_896b32_4x_ft4x_max-size.pth"
-cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5  # set threshold for this model
-cfg.MODEL.ROI_BOX_HEAD.ZEROSHOT_WEIGHT_PATH = "rand"
-cfg.MODEL.ROI_HEADS.ONE_CLASS_PER_PROPOSAL = (
-    True  # For better visualization purpose. Set to False for all classes.
-)
-predictor = DefaultPredictor(cfg)
-
-# Setup the model's vocabulary using build-in datasets
-
-BUILDIN_CLASSIFIER = {
-    "lvis": "datasets/metadata/lvis_v1_clip_a+cname.npy",
-    "objects365": "datasets/metadata/o365_clip_a+cnamefix.npy",
-    "openimages": "datasets/metadata/oid_clip_a+cname.npy",
-    "coco": "datasets/metadata/coco_clip_a+cname.npy",
-}
-
-BUILDIN_METADATA_PATH = {
-    "lvis": "lvis_v1_val",
-    "objects365": "objects365_v2_val",
-    "openimages": "oid_val_expanded",
-    "coco": "coco_2017_val",
-}
-
-vocabulary = "lvis"  # change to 'lvis', 'objects365', 'openimages', or 'coco'
-metadata = MetadataCatalog.get(BUILDIN_METADATA_PATH[vocabulary])
-classifier = BUILDIN_CLASSIFIER[vocabulary]
-num_classes = len(metadata.thing_classes)
-reset_cls_test(predictor.model, classifier, num_classes)
-
-session_token = os.environ.get("SessionToken")
-
-
-def get_response_from_chatbot(text):
-    try:
-        api = ChatGPT(session_token)
-        resp = api.send_message(text)
-        api.refresh_auth()
-        api.reset_conversation()
-        response = resp["message"]
-    except:
-        response = "Sorry, I'm busy. Try again later."
-    return response
-
-
-def inference(img):
-
-    im = cv2.imread(img)
-
-    outputs = predictor(im)
-    v = Visualizer(im[:, :, ::-1], metadata)
-    out = v.draw_instance_predictions(outputs["instances"].to("cpu"))
-
-    detected_objects = []
-    object_list_str = []
-
-    box_locations = outputs["instances"].pred_boxes
-    box_loc_screen = box_locations.tensor.cpu().numpy()
-
-    for i, box_coord in enumerate(box_loc_screen):
-        x0, y0, x1, y1 = box_coord
-        width = x1 - x0
-        height = y1 - y0
-        predicted_label = metadata.thing_classes[outputs["instances"].pred_classes[i]]
-        detected_objects.append(
-            {
-                "prediction": predicted_label,
-                "x": int(x0),
-                "y": int(y0),
-                "w": int(width),
-                "h": int(height),
-            }
-        )
-        object_list_str.append(
-            f"{predicted_label} - X:({int(x0)} Y: {int(y0)} Width {int(width)} Height: {int(height)})"
-        )
-
-    chat_gpt_response = get_response_from_chatbot(
-        f"You are an intelligent image captioner. I will hand you the objects and their position, and you should give me a detailed description for the photo. In this photo we have the following objects\n{object_list_str}"
-    )
-
-    return (
-        Image.fromarray(np.uint8(out.get_image())).convert("RGB"),
-        chat_gpt_response,
-    )
-
-
-with gr.Blocks() as demo:
-    gr.Markdown("# Detic+ChatGPT")
-    gr.Markdown("Use Detic to detect objects in an image and then use ChatGPT to describe the image.")
-    
-    gr.HTML("<p>You can duplicating this space and use your own session token: <a style='display:inline-block' href='https://huggingface.co/spaces/yizhangliu/chatGPT?duplicate=true'><img src='https://img.shields.io/badge/-Duplicate%20Space-blue?labelColor=white&style=flat&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAP5JREFUOE+lk7FqAkEURY+ltunEgFXS2sZGIbXfEPdLlnxJyDdYB62sbbUKpLbVNhyYFzbrrA74YJlh9r079973psed0cvUD4A+4HoCjsA85X0Dfn/RBLBgBDxnQPfAEJgBY+A9gALA4tcbamSzS4xq4FOQAJgCDwV2CPKV8tZAJcAjMMkUe1vX+U+SMhfAJEHasQIWmXNN3abzDwHUrgcRGmYcgKe0bxrblHEB4E/pndMazNpSZGcsZdBlYJcEL9Afo75molJyM2FxmPgmgPqlWNLGfwZGG6UiyEvLzHYDmoPkDDiNm9JR9uboiONcBXrpY1qmgs21x1QwyZcpvxt9NS09PlsPAAAAAElFTkSuQmCC&logoWidth=14' alt='Duplicate Space'></a></p>")
-    gr.HTML("<p> Instruction on how to get session token can be seen in video <a style='display:inline-block' href='https://www.youtube.com/watch?v=TdNSj_qgdFk'><font style='color:blue;weight:bold;'>here</font></a>. Add your session token by going to settings and add under secrets. </p>")
-   
-    with gr.Column():
-        inp = gr.Image(label="Input Image", type="filepath")
-        btn_detic = gr.Button("Run Detic+ChatGPT")
-    with gr.Column():
-        outviz = gr.Image(label="Visualization", type="pil")
-        output_desc = gr.Textbox(label="chatGPT Description", lines=5)
-        # outputjson = gr.JSON(label="Detected Objects")
-
-    btn_detic.click(fn=inference, inputs=inp, outputs=[outviz, output_desc])
-
-demo.launch()
diff --git a/spaces/Detomo/ai-comic-generation/src/components/ui/separator.tsx b/spaces/Detomo/ai-comic-generation/src/components/ui/separator.tsx
deleted file mode 100644
index a6ed83ef827829cf42a7b27d1d5714b4473bd1c5..0000000000000000000000000000000000000000
--- a/spaces/Detomo/ai-comic-generation/src/components/ui/separator.tsx
+++ /dev/null
@@ -1,31 +0,0 @@
-"use client"
-
-import * as React from "react"
-import * as SeparatorPrimitive from "@radix-ui/react-separator"
-
-import { cn } from "@/lib/utils"
-
-const Separator = React.forwardRef<
-  React.ElementRef<typeof SeparatorPrimitive.Root>,
-  React.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root>
->(
-  (
-    { className, orientation = "horizontal", decorative = true, ...props },
-    ref
-  ) => (
-    <SeparatorPrimitive.Root
-      ref={ref}
-      decorative={decorative}
-      orientation={orientation}
-      className={cn(
-        "shrink-0 bg-stone-200 dark:bg-stone-800",
-        orientation === "horizontal" ? "h-[1px] w-full" : "h-full w-[1px]",
-        className
-      )}
-      {...props}
-    />
-  )
-)
-Separator.displayName = SeparatorPrimitive.Root.displayName
-
-export { Separator }
diff --git a/spaces/Djacon/emotion_detection/Dockerfile b/spaces/Djacon/emotion_detection/Dockerfile
deleted file mode 100644
index b742a1870b92ce033b776c0defec1a9996889d50..0000000000000000000000000000000000000000
--- a/spaces/Djacon/emotion_detection/Dockerfile
+++ /dev/null
@@ -1,11 +0,0 @@
-FROM python:3.9
-
-WORKDIR /code
-
-COPY ./requirements.txt /code/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-COPY . .
-
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
\ No newline at end of file
diff --git a/spaces/Drac77/stabilityai-stable-diffusion-xl-base-1.0/README.md b/spaces/Drac77/stabilityai-stable-diffusion-xl-base-1.0/README.md
deleted file mode 100644
index 5eebb78c642601314fe573d9fd0717bd14763410..0000000000000000000000000000000000000000
--- a/spaces/Drac77/stabilityai-stable-diffusion-xl-base-1.0/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Stabilityai Stable Diffusion Xl Base 1.0
-emoji: 🔥
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 3.47.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Duskfallcrew/isometric-dreams-sd-1-5/app.py b/spaces/Duskfallcrew/isometric-dreams-sd-1-5/app.py
deleted file mode 100644
index 0c94630f544a11c084e58ec1621081af6d2dfa08..0000000000000000000000000000000000000000
--- a/spaces/Duskfallcrew/isometric-dreams-sd-1-5/app.py
+++ /dev/null
@@ -1,143 +0,0 @@
-from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, DPMSolverMultistepScheduler
-import gradio as gr
-import torch
-from PIL import Image
-
-model_id = 'Duskfallcrew/isometric-dreams-sd-1-5'
-prefix = 'duskametrick15'
-     
-scheduler = DPMSolverMultistepScheduler.from_pretrained(model_id, subfolder="scheduler")
-
-pipe = StableDiffusionPipeline.from_pretrained(
-  model_id,
-  torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-  scheduler=scheduler)
-
-pipe_i2i = StableDiffusionImg2ImgPipeline.from_pretrained(
-  model_id,
-  torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-  scheduler=scheduler)
-
-if torch.cuda.is_available():
-  pipe = pipe.to("cuda")
-  pipe_i2i = pipe_i2i.to("cuda")
-
-def error_str(error, title="Error"):
-    return f"""#### {title}
-            {error}"""  if error else ""
-
-def inference(prompt, guidance, steps, width=512, height=512, seed=0, img=None, strength=0.5, neg_prompt="", auto_prefix=False):
-
-  generator = torch.Generator('cuda').manual_seed(seed) if seed != 0 else None
-  prompt = f"{prefix} {prompt}" if auto_prefix else prompt
-
-  try:
-    if img is not None:
-      return img_to_img(prompt, neg_prompt, img, strength, guidance, steps, width, height, generator), None
-    else:
-      return txt_to_img(prompt, neg_prompt, guidance, steps, width, height, generator), None
-  except Exception as e:
-    return None, error_str(e)
-
-def txt_to_img(prompt, neg_prompt, guidance, steps, width, height, generator):
-
-    result = pipe(
-      prompt,
-      negative_prompt = neg_prompt,
-      num_inference_steps = int(steps),
-      guidance_scale = guidance,
-      width = width,
-      height = height,
-      generator = generator)
-    
-    return result.images[0]
-
-def img_to_img(prompt, neg_prompt, img, strength, guidance, steps, width, height, generator):
-
-    ratio = min(height / img.height, width / img.width)
-    img = img.resize((int(img.width * ratio), int(img.height * ratio)), Image.LANCZOS)
-    result = pipe_i2i(
-        prompt,
-        negative_prompt = neg_prompt,
-        init_image = img,
-        num_inference_steps = int(steps),
-        strength = strength,
-        guidance_scale = guidance,
-        width = width,
-        height = height,
-        generator = generator)
-        
-    return result.images[0]
-
-css = """.main-div div{display:inline-flex;align-items:center;gap:.8rem;font-size:1.75rem}.main-div div h1{font-weight:900;margin-bottom:7px}.main-div p{margin-bottom:10px;font-size:94%}a{text-decoration:underline}.tabs{margin-top:0;margin-bottom:0}#gallery{min-height:20rem}
-"""
-with gr.Blocks(css=css) as demo:
-    gr.HTML(
-        f"""
-            <div class="main-div">
-              <div>
-                <h1>Isometric Dreams (1.5)</h1>
-              </div>
-              <p>
-               Demo for <a href="https://huggingface.co/Duskfallcrew/isometric-dreams-sd-1-5">Isometric Dreams Sd 1 5</a> Stable Diffusion model.
-
-<a href="https://civitai.com/user/duskfallcrew">All samples and info are here on CivitAi </a>
-
-<a href="https://ko-fi.com/DUSKFALLcrewKo-Fi"></a>
-
-duskametrick15 (use that on your prompt)<br>
-               {"Add the following tokens to your prompts for the model to work properly: <b>prefix</b>" if prefix else ""}
-              </p>
-              Running on {"<b>GPU 🔥</b>" if torch.cuda.is_available() else f"<b>CPU 🥶</b>. For faster inference it is recommended to <b>upgrade to GPU in <a href='https://huggingface.co/spaces/Duskfallcrew/isometric-dreams-sd-1-5/settings'>Settings</a></b>"} after duplicating the space<br><br>
-              <a style="display:inline-block" href="https://huggingface.co/spaces/Duskfallcrew/isometric-dreams-sd-1-5?duplicate=true"><img src="https://bit.ly/3gLdBN6" alt="Duplicate Space"></a>
-            </div>
-        """
-    )
-    with gr.Row():
-        
-        with gr.Column(scale=55):
-          with gr.Group():
-              with gr.Row():
-                prompt = gr.Textbox(label="Prompt", show_label=False, max_lines=2,placeholder=f"{prefix} [your prompt]").style(container=False)
-                generate = gr.Button(value="Generate").style(rounded=(False, True, True, False))
-
-              image_out = gr.Image(height=512)
-          error_output = gr.Markdown()
-
-        with gr.Column(scale=45):
-          with gr.Tab("Options"):
-            with gr.Group():
-              neg_prompt = gr.Textbox(label="Negative prompt", placeholder="What to exclude from the image")
-              auto_prefix = gr.Checkbox(label="Prefix styling tokens automatically (duskametrick15)", value=prefix, visible=prefix)
-
-              with gr.Row():
-                guidance = gr.Slider(label="Guidance scale", value=7.5, maximum=15)
-                steps = gr.Slider(label="Steps", value=25, minimum=2, maximum=75, step=1)
-
-              with gr.Row():
-                width = gr.Slider(label="Width", value=512, minimum=64, maximum=1024, step=8)
-                height = gr.Slider(label="Height", value=512, minimum=64, maximum=1024, step=8)
-
-              seed = gr.Slider(0, 2147483647, label='Seed (0 = random)', value=0, step=1)
-
-          with gr.Tab("Image to image"):
-              with gr.Group():
-                image = gr.Image(label="Image", height=256, tool="editor", type="pil")
-                strength = gr.Slider(label="Transformation strength", minimum=0, maximum=1, step=0.01, value=0.5)
-
-    auto_prefix.change(lambda x: gr.update(placeholder=f"{prefix} [your prompt]" if x else "[Your prompt]"), inputs=auto_prefix, outputs=prompt, queue=False)
-
-    inputs = [prompt, guidance, steps, width, height, seed, image, strength, neg_prompt, auto_prefix]
-    outputs = [image_out, error_output]
-    prompt.submit(inference, inputs=inputs, outputs=outputs)
-    generate.click(inference, inputs=inputs, outputs=outputs)
-
-    gr.HTML("""
-    <div style="border-top: 1px solid #303030;">
-      <br>
-      <p>This space was created using <a href="https://huggingface.co/spaces/anzorq/sd-space-creator">SD Space Creator</a>.</p>
-    </div>
-    """)
-
-demo.queue(concurrency_count=1)
-demo.launch()
diff --git a/spaces/Eddycrack864/Applio-Inference/Applio-RVC-Fork/utils/backups_test.py b/spaces/Eddycrack864/Applio-Inference/Applio-RVC-Fork/utils/backups_test.py
deleted file mode 100644
index f3edf15811b5035ee82f21e54e87b7e87ce413eb..0000000000000000000000000000000000000000
--- a/spaces/Eddycrack864/Applio-Inference/Applio-RVC-Fork/utils/backups_test.py
+++ /dev/null
@@ -1,138 +0,0 @@
-
-import os
-import shutil
-import hashlib
-import time
-
-LOGS_FOLDER = '/content/Applio-RVC-Fork/logs'
-WEIGHTS_FOLDER = '/content/Applio-RVC-Fork/weights'
-GOOGLE_DRIVE_PATH = '/content/drive/MyDrive/RVC_Backup'
-
-def import_google_drive_backup():
-    print("Importing Google Drive backup...")
-    GOOGLE_DRIVE_PATH = '/content/drive/MyDrive/RVC_Backup'  # change this to your Google Drive path
-    LOGS_FOLDER = '/content/Applio-RVC-Fork/logs'
-    WEIGHTS_FOLDER = '/content/Applio-RVC-Fork/weights'
-    weights_exist = False
-    files_to_copy = []
-    weights_to_copy = []
-    
-    def handle_files(root, files, is_weight_files=False):
-        for filename in files:
-            filepath = os.path.join(root, filename)
-            if filename.endswith('.pth') and is_weight_files:
-                weights_exist = True
-                backup_filepath = os.path.join(WEIGHTS_FOLDER, os.path.relpath(filepath, GOOGLE_DRIVE_PATH))
-            else:
-                backup_filepath = os.path.join(LOGS_FOLDER, os.path.relpath(filepath, GOOGLE_DRIVE_PATH))
-            backup_folderpath = os.path.dirname(backup_filepath)
-            if not os.path.exists(backup_folderpath):
-                os.makedirs(backup_folderpath)
-                print(f'Created folder: {backup_folderpath}', flush=True)
-            if is_weight_files:
-                weights_to_copy.append((filepath, backup_filepath))
-            else:
-                files_to_copy.append((filepath, backup_filepath))
-
-    for root, dirs, files in os.walk(os.path.join(GOOGLE_DRIVE_PATH, 'logs')):
-        handle_files(root, files)
-    
-    for root, dirs, files in os.walk(os.path.join(GOOGLE_DRIVE_PATH, 'weights')):
-        handle_files(root, files, True)
-
-    # Copy files in batches
-    total_files = len(files_to_copy)
-    start_time = time.time()
-    for i, (source, dest) in enumerate(files_to_copy, start=1):
-        with open(source, 'rb') as src, open(dest, 'wb') as dst:
-            shutil.copyfileobj(src, dst, 1024*1024)  # 1MB buffer size
-        # Report progress every 5 seconds or after every 100 files, whichever is less frequent
-        if time.time() - start_time > 5 or i % 100 == 0:
-            print(f'\rCopying file {i} of {total_files} ({i * 100 / total_files:.2f}%)', end="")
-            start_time = time.time()
-    print(f'\nImported {len(files_to_copy)} files from Google Drive backup')
-
-    # Copy weights in batches
-    total_weights = len(weights_to_copy)
-    start_time = time.time()
-    for i, (source, dest) in enumerate(weights_to_copy, start=1):
-        with open(source, 'rb') as src, open(dest, 'wb') as dst:
-            shutil.copyfileobj(src, dst, 1024*1024)  # 1MB buffer size
-        # Report progress every 5 seconds or after every 100 files, whichever is less frequent
-        if time.time() - start_time > 5 or i % 100 == 0:
-            print(f'\rCopying weight file {i} of {total_weights} ({i * 100 / total_weights:.2f}%)', end="")
-            start_time = time.time()
-    if weights_exist:
-        print(f'\nImported {len(weights_to_copy)} weight files')
-        print("Copied weights from Google Drive backup to local weights folder.")
-    else:
-        print("\nNo weights found in Google Drive backup.")
-    print("Google Drive backup import completed.")
-
-def backup_files():
-    print("\n Starting backup loop...")
-    last_backup_timestamps_path = os.path.join(LOGS_FOLDER, 'last_backup_timestamps.txt')
-    fully_updated = False  # boolean to track if all files are up to date
-    try:
-        with open(last_backup_timestamps_path, 'r') as f:
-            last_backup_timestamps = dict(line.strip().split(':') for line in f)
-    except:
-        last_backup_timestamps = {}
-
-    while True:
-        updated = False
-        files_to_copy = []
-        files_to_delete = []
-
-        for root, dirs, files in os.walk(LOGS_FOLDER):
-            for filename in files:
-                if filename != 'last_backup_timestamps.txt':
-                    filepath = os.path.join(root, filename)
-                    if os.path.isfile(filepath):
-                        backup_filepath = os.path.join(GOOGLE_DRIVE_PATH, os.path.relpath(filepath, LOGS_FOLDER))
-                        backup_folderpath = os.path.dirname(backup_filepath)
-
-                        if not os.path.exists(backup_folderpath):
-                            os.makedirs(backup_folderpath)
-                            print(f'Created backup folder: {backup_folderpath}', flush=True)
-
-                        # check if file has changed since last backup
-                        last_backup_timestamp = last_backup_timestamps.get(filepath)
-                        current_timestamp = os.path.getmtime(filepath)
-                        if last_backup_timestamp is None or float(last_backup_timestamp) < current_timestamp:
-                            files_to_copy.append((filepath, backup_filepath))  # add to list of files to copy
-                            last_backup_timestamps[filepath] = str(current_timestamp)  # update last backup timestamp
-                            updated = True
-                            fully_updated = False  # if a file is updated, all files are not up to date
-
-        # check if any files were deleted in Colab and delete them from the backup drive
-        for filepath in list(last_backup_timestamps.keys()):
-            if not os.path.exists(filepath):
-                backup_filepath = os.path.join(GOOGLE_DRIVE_PATH, os.path.relpath(filepath, LOGS_FOLDER))
-                if os.path.exists(backup_filepath):
-                    files_to_delete.append(backup_filepath)  # add to list of files to delete
-                del last_backup_timestamps[filepath]
-                updated = True
-                fully_updated = False  # if a file is deleted, all files are not up to date
-
-        # Copy files in batches
-        if files_to_copy:
-            for source, dest in files_to_copy:
-                shutil.copy2(source, dest)
-            print(f'Copied or updated {len(files_to_copy)} files')
-
-        # Delete files in batches
-        if files_to_delete:
-            for file in files_to_delete:
-                os.remove(file)
-            print(f'Deleted {len(files_to_delete)} files')
-
-        if not updated and not fully_updated:
-            print("Files are up to date.")
-            fully_updated = True  # if all files are up to date, set the boolean to True
-            copy_weights_folder_to_drive()
-
-        with open(last_backup_timestamps_path, 'w') as f:
-            for filepath, timestamp in last_backup_timestamps.items():
-                f.write(f'{filepath}:{timestamp}\n')
-        time.sleep(15)  # wait for 15 seconds before checking again
diff --git a/spaces/EronSamez/RVC_HFmeu/infer/lib/uvr5_pack/lib_v5/nets_new.py b/spaces/EronSamez/RVC_HFmeu/infer/lib/uvr5_pack/lib_v5/nets_new.py
deleted file mode 100644
index 1c0f4fa96d921e979fe31bd4151701b7783fbcea..0000000000000000000000000000000000000000
--- a/spaces/EronSamez/RVC_HFmeu/infer/lib/uvr5_pack/lib_v5/nets_new.py
+++ /dev/null
@@ -1,133 +0,0 @@
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from . import layers_new
-
-
-class BaseNet(nn.Module):
-    def __init__(
-        self, nin, nout, nin_lstm, nout_lstm, dilations=((4, 2), (8, 4), (12, 6))
-    ):
-        super(BaseNet, self).__init__()
-        self.enc1 = layers_new.Conv2DBNActiv(nin, nout, 3, 1, 1)
-        self.enc2 = layers_new.Encoder(nout, nout * 2, 3, 2, 1)
-        self.enc3 = layers_new.Encoder(nout * 2, nout * 4, 3, 2, 1)
-        self.enc4 = layers_new.Encoder(nout * 4, nout * 6, 3, 2, 1)
-        self.enc5 = layers_new.Encoder(nout * 6, nout * 8, 3, 2, 1)
-
-        self.aspp = layers_new.ASPPModule(nout * 8, nout * 8, dilations, dropout=True)
-
-        self.dec4 = layers_new.Decoder(nout * (6 + 8), nout * 6, 3, 1, 1)
-        self.dec3 = layers_new.Decoder(nout * (4 + 6), nout * 4, 3, 1, 1)
-        self.dec2 = layers_new.Decoder(nout * (2 + 4), nout * 2, 3, 1, 1)
-        self.lstm_dec2 = layers_new.LSTMModule(nout * 2, nin_lstm, nout_lstm)
-        self.dec1 = layers_new.Decoder(nout * (1 + 2) + 1, nout * 1, 3, 1, 1)
-
-    def __call__(self, x):
-        e1 = self.enc1(x)
-        e2 = self.enc2(e1)
-        e3 = self.enc3(e2)
-        e4 = self.enc4(e3)
-        e5 = self.enc5(e4)
-
-        h = self.aspp(e5)
-
-        h = self.dec4(h, e4)
-        h = self.dec3(h, e3)
-        h = self.dec2(h, e2)
-        h = torch.cat([h, self.lstm_dec2(h)], dim=1)
-        h = self.dec1(h, e1)
-
-        return h
-
-
-class CascadedNet(nn.Module):
-    def __init__(self, n_fft, nout=32, nout_lstm=128):
-        super(CascadedNet, self).__init__()
-
-        self.max_bin = n_fft // 2
-        self.output_bin = n_fft // 2 + 1
-        self.nin_lstm = self.max_bin // 2
-        self.offset = 64
-
-        self.stg1_low_band_net = nn.Sequential(
-            BaseNet(2, nout // 2, self.nin_lstm // 2, nout_lstm),
-            layers_new.Conv2DBNActiv(nout // 2, nout // 4, 1, 1, 0),
-        )
-
-        self.stg1_high_band_net = BaseNet(
-            2, nout // 4, self.nin_lstm // 2, nout_lstm // 2
-        )
-
-        self.stg2_low_band_net = nn.Sequential(
-            BaseNet(nout // 4 + 2, nout, self.nin_lstm // 2, nout_lstm),
-            layers_new.Conv2DBNActiv(nout, nout // 2, 1, 1, 0),
-        )
-        self.stg2_high_band_net = BaseNet(
-            nout // 4 + 2, nout // 2, self.nin_lstm // 2, nout_lstm // 2
-        )
-
-        self.stg3_full_band_net = BaseNet(
-            3 * nout // 4 + 2, nout, self.nin_lstm, nout_lstm
-        )
-
-        self.out = nn.Conv2d(nout, 2, 1, bias=False)
-        self.aux_out = nn.Conv2d(3 * nout // 4, 2, 1, bias=False)
-
-    def forward(self, x):
-        x = x[:, :, : self.max_bin]
-
-        bandw = x.size()[2] // 2
-        l1_in = x[:, :, :bandw]
-        h1_in = x[:, :, bandw:]
-        l1 = self.stg1_low_band_net(l1_in)
-        h1 = self.stg1_high_band_net(h1_in)
-        aux1 = torch.cat([l1, h1], dim=2)
-
-        l2_in = torch.cat([l1_in, l1], dim=1)
-        h2_in = torch.cat([h1_in, h1], dim=1)
-        l2 = self.stg2_low_band_net(l2_in)
-        h2 = self.stg2_high_band_net(h2_in)
-        aux2 = torch.cat([l2, h2], dim=2)
-
-        f3_in = torch.cat([x, aux1, aux2], dim=1)
-        f3 = self.stg3_full_band_net(f3_in)
-
-        mask = torch.sigmoid(self.out(f3))
-        mask = F.pad(
-            input=mask,
-            pad=(0, 0, 0, self.output_bin - mask.size()[2]),
-            mode="replicate",
-        )
-
-        if self.training:
-            aux = torch.cat([aux1, aux2], dim=1)
-            aux = torch.sigmoid(self.aux_out(aux))
-            aux = F.pad(
-                input=aux,
-                pad=(0, 0, 0, self.output_bin - aux.size()[2]),
-                mode="replicate",
-            )
-            return mask, aux
-        else:
-            return mask
-
-    def predict_mask(self, x):
-        mask = self.forward(x)
-
-        if self.offset > 0:
-            mask = mask[:, :, :, self.offset : -self.offset]
-            assert mask.size()[3] > 0
-
-        return mask
-
-    def predict(self, x, aggressiveness=None):
-        mask = self.forward(x)
-        pred_mag = x * mask
-
-        if self.offset > 0:
-            pred_mag = pred_mag[:, :, :, self.offset : -self.offset]
-            assert pred_mag.size()[3] > 0
-
-        return pred_mag
diff --git a/spaces/Flux9665/IMS-Toucan/Layers/MultiSequential.py b/spaces/Flux9665/IMS-Toucan/Layers/MultiSequential.py
deleted file mode 100644
index bccf8cd18bf94a42fcc1ef94f3fb23e86a114394..0000000000000000000000000000000000000000
--- a/spaces/Flux9665/IMS-Toucan/Layers/MultiSequential.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# Written by Shigeki Karita, 2019
-# Published under Apache 2.0  (http://www.apache.org/licenses/LICENSE-2.0)
-# Adapted by Florian Lux, 2021
-
-import torch
-
-
-class MultiSequential(torch.nn.Sequential):
-    """
-    Multi-input multi-output torch.nn.Sequential.
-    """
-
-    def forward(self, *args):
-        """
-        Repeat.
-        """
-        for m in self:
-            args = m(*args)
-        return args
-
-
-def repeat(N, fn):
-    """
-    Repeat module N times.
-
-    Args:
-        N (int): Number of repeat time.
-        fn (Callable): Function to generate module.
-
-    Returns:
-        MultiSequential: Repeated model instance.
-    """
-    return MultiSequential(*[fn(n) for n in range(N)])
diff --git a/spaces/FrankZxShen/so-vits-svc-models-pcr/inference/__init__.py b/spaces/FrankZxShen/so-vits-svc-models-pcr/inference/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/GaenKoki/voicevox/test/test_mora_list.py b/spaces/GaenKoki/voicevox/test/test_mora_list.py
deleted file mode 100644
index 25b287fa0e8b0febb1895ac84223823915e548ea..0000000000000000000000000000000000000000
--- a/spaces/GaenKoki/voicevox/test/test_mora_list.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from unittest import TestCase
-
-from voicevox_engine.mora_list import openjtalk_mora2text
-
-
-class TestOpenJTalkMoraList(TestCase):
-    def test_mora2text(self):
-        self.assertEqual("ッ", openjtalk_mora2text["cl"])
-        self.assertEqual("ティ", openjtalk_mora2text["ti"])
-        self.assertEqual("トゥ", openjtalk_mora2text["tu"])
-        self.assertEqual("ディ", openjtalk_mora2text["di"])
-        # GitHub issue #60
-        self.assertEqual("ギェ", openjtalk_mora2text["gye"])
-        self.assertEqual("イェ", openjtalk_mora2text["ye"])
-
-    def test_mora2text_injective(self):
-        """異なるモーラが同じ読みがなに対応しないか確認する"""
-        values = list(openjtalk_mora2text.values())
-        uniq_values = list(set(values))
-        self.assertCountEqual(values, uniq_values)
diff --git a/spaces/GaenKoki/voicevox/voicevox_engine/acoustic_feature_extractor.py b/spaces/GaenKoki/voicevox/voicevox_engine/acoustic_feature_extractor.py
deleted file mode 100644
index 8fa37fbae8badda63d9fe7173cf407eb25343144..0000000000000000000000000000000000000000
--- a/spaces/GaenKoki/voicevox/voicevox_engine/acoustic_feature_extractor.py
+++ /dev/null
@@ -1,332 +0,0 @@
-from abc import abstractmethod
-from enum import Enum
-from pathlib import Path
-from typing import List, Sequence
-
-import numpy
-
-
-class BasePhoneme(object):
-    """
-    音素の応用クラス群の抽象基底クラス
-
-    Attributes
-    ----------
-    phoneme_list : Sequence[str]
-        音素のリスト
-    num_phoneme : int
-        音素リストの要素数
-    space_phoneme : str
-        読点に値する音素
-    """
-
-    phoneme_list: Sequence[str]
-    num_phoneme: int
-    space_phoneme: str
-
-    def __init__(
-        self,
-        phoneme: str,
-        start: float,
-        end: float,
-    ):
-        self.phoneme = phoneme
-        self.start = numpy.round(start, decimals=2)
-        self.end = numpy.round(end, decimals=2)
-
-    def __repr__(self):
-        return f"Phoneme(phoneme='{self.phoneme}', start={self.start}, end={self.end})"
-
-    def __eq__(self, o: object):
-        return isinstance(o, BasePhoneme) and (
-            self.phoneme == o.phoneme and self.start == o.start and self.end == o.end
-        )
-
-    def verify(self):
-        """
-        音素クラスとして、データが正しいかassertする
-        """
-        assert self.phoneme in self.phoneme_list, f"{self.phoneme} is not defined."
-
-    @property
-    def phoneme_id(self):
-        """
-        phoneme_id (phoneme list内でのindex)を取得する
-        Returns
-        -------
-        id : int
-            phoneme_idを返す
-        """
-        return self.phoneme_list.index(self.phoneme)
-
-    @property
-    def duration(self):
-        """
-        音素継続期間を取得する
-        Returns
-        -------
-        duration : int
-            音素継続期間を返す
-        """
-        return self.end - self.start
-
-    @property
-    def onehot(self):
-        """
-        phoneme listの長さ分の0埋め配列のうち、phoneme id番目がTrue(1)の配列を返す
-        Returns
-        -------
-        onehot : numpu.ndarray
-            関数内で変更された配列を返す
-        """
-        array = numpy.zeros(self.num_phoneme, dtype=bool)
-        array[self.phoneme_id] = True
-        return array
-
-    @classmethod
-    def parse(cls, s: str):
-        """
-        文字列をパースして音素クラスを作る
-        Parameters
-        ----------
-        s : str
-            パースしたい文字列
-
-        Returns
-        -------
-        phoneme : BasePhoneme
-            パース結果を用いた音素クラスを返す
-
-        Examples
-        --------
-        >>> BasePhoneme.parse('1.7425000 1.9125000 o:')
-        Phoneme(phoneme='o:', start=1.74, end=1.91)
-        """
-        words = s.split()
-        return cls(
-            start=float(words[0]),
-            end=float(words[1]),
-            phoneme=words[2],
-        )
-
-    @classmethod
-    @abstractmethod
-    def convert(cls, phonemes: List["BasePhoneme"]) -> List["BasePhoneme"]:
-        raise NotImplementedError
-
-    @classmethod
-    def load_lab_list(cls, path: Path):
-        """
-        labファイルを読み込む
-        Parameters
-        ----------
-        path : Path
-            読み込みたいlabファイルのパス
-
-        Returns
-        -------
-        phonemes : List[BasePhoneme]
-            パース結果を用いた音素クラスを返す
-        """
-        phonemes = [cls.parse(s) for s in path.read_text().split("\n") if len(s) > 0]
-        phonemes = cls.convert(phonemes)
-
-        for phoneme in phonemes:
-            phoneme.verify()
-        return phonemes
-
-    @classmethod
-    def save_lab_list(cls, phonemes: List["BasePhoneme"], path: Path):
-        """
-        音素クラスのリストをlabファイル形式で保存する
-        Parameters
-        ----------
-        phonemes : List[BasePhoneme]
-            保存したい音素クラスのリスト
-        path : Path
-            labファイルの保存先パス
-        """
-        text = "\n".join(
-            [
-                f"{numpy.round(p.start, decimals=2):.2f}\t"
-                f"{numpy.round(p.end, decimals=2):.2f}\t"
-                f"{p.phoneme}"
-                for p in phonemes
-            ]
-        )
-        path.write_text(text)
-
-
-class JvsPhoneme(BasePhoneme):
-    """
-    JVS(Japanese versatile speech)コーパスに含まれる音素群クラス
-
-    Attributes
-    ----------
-    phoneme_list : Sequence[str]
-        音素のリスト
-    num_phoneme : int
-        音素リストの要素数
-    space_phoneme : str
-        読点に値する音素
-    """
-
-    phoneme_list = (
-        "pau",
-        "I",
-        "N",
-        "U",
-        "a",
-        "b",
-        "by",
-        "ch",
-        "cl",
-        "d",
-        "dy",
-        "e",
-        "f",
-        "g",
-        "gy",
-        "h",
-        "hy",
-        "i",
-        "j",
-        "k",
-        "ky",
-        "m",
-        "my",
-        "n",
-        "ny",
-        "o",
-        "p",
-        "py",
-        "r",
-        "ry",
-        "s",
-        "sh",
-        "t",
-        "ts",
-        "u",
-        "v",
-        "w",
-        "y",
-        "z",
-    )
-    num_phoneme = len(phoneme_list)
-    space_phoneme = "pau"
-
-    @classmethod
-    def convert(cls, phonemes: List["JvsPhoneme"]) -> List["JvsPhoneme"]:
-        """
-        最初と最後のsil(silent)をspace_phoneme(pau)に置き換え(変換)する
-        Parameters
-        ----------
-        phonemes : List[JvsPhoneme]
-            変換したいphonemeのリスト
-
-        Returns
-        -------
-        phonemes : List[JvsPhoneme]
-            変換されたphonemeのリスト
-        """
-        if "sil" in phonemes[0].phoneme:
-            phonemes[0].phoneme = cls.space_phoneme
-        if "sil" in phonemes[-1].phoneme:
-            phonemes[-1].phoneme = cls.space_phoneme
-        return phonemes
-
-
-class OjtPhoneme(BasePhoneme):
-    """
-    OpenJTalkに含まれる音素群クラス
-
-    Attributes
-    ----------
-    phoneme_list : Sequence[str]
-        音素のリスト
-    num_phoneme : int
-        音素リストの要素数
-    space_phoneme : str
-        読点に値する音素
-    """
-
-    phoneme_list = (
-        "pau",
-        "A",
-        "E",
-        "I",
-        "N",
-        "O",
-        "U",
-        "a",
-        "b",
-        "by",
-        "ch",
-        "cl",
-        "d",
-        "dy",
-        "e",
-        "f",
-        "g",
-        "gw",
-        "gy",
-        "h",
-        "hy",
-        "i",
-        "j",
-        "k",
-        "kw",
-        "ky",
-        "m",
-        "my",
-        "n",
-        "ny",
-        "o",
-        "p",
-        "py",
-        "r",
-        "ry",
-        "s",
-        "sh",
-        "t",
-        "ts",
-        "ty",
-        "u",
-        "v",
-        "w",
-        "y",
-        "z",
-    )
-    num_phoneme = len(phoneme_list)
-    space_phoneme = "pau"
-
-    @classmethod
-    def convert(cls, phonemes: List["OjtPhoneme"]):
-        """
-        最初と最後のsil(silent)をspace_phoneme(pau)に置き換え(変換)する
-        Parameters
-        ----------
-        phonemes : List[OjtPhoneme]
-            変換したいphonemeのリスト
-
-        Returns
-        -------
-        phonemes : List[OjtPhoneme]
-            変換されたphonemeのリスト
-        """
-        if "sil" in phonemes[0].phoneme:
-            phonemes[0].phoneme = cls.space_phoneme
-        if "sil" in phonemes[-1].phoneme:
-            phonemes[-1].phoneme = cls.space_phoneme
-        return phonemes
-
-
-class PhonemeType(str, Enum):
-    jvs = "jvs"
-    openjtalk = "openjtalk"
-
-
-phoneme_type_to_class = {
-    PhonemeType.jvs: JvsPhoneme,
-    PhonemeType.openjtalk: OjtPhoneme,
-}
diff --git a/spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/sort_insert_color_coordinated_blocks.py b/spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/sort_insert_color_coordinated_blocks.py
deleted file mode 100644
index 1ef6783dee825ecf1d4a4dfd2b97889adf88d394..0000000000000000000000000000000000000000
--- a/spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/sort_insert_color_coordinated_blocks.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import numpy as np
-import os
-import pybullet as p
-import random
-from cliport.tasks import primitives
-from cliport.tasks.grippers import Spatula
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-
-class SortInsertColorCoordinatedBlocks(Task):
-    """Sort blocks by their colors and place them into the containers of the matching color."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 20
-        self.lang_template = "sort the blocks by their colors and place them into the containers of the matching color"
-        self.task_completed_desc = "done sorting and inserting blocks."
-        self.additional_reset()
-
-    def reset(self, env):
-        super().reset(env)
-
-        # Add containers.
-        container_size = (0.12, 0.12, 0.12)
-        container_size = (0.1, 0.1, 0.1)
-        container_pose = self.get_random_pose(env, container_size)
-        container_urdf = 'container/container-template.urdf'
-        replace = {'DIM': container_size, 'HALF': (container_size[0] / 2, container_size[1] / 2, container_size[2] / 2)}
-        container_urdf = self.fill_template(container_urdf, replace)
-        container_colors = ['red', 'blue', 'green']
-        container_poses = []
-        for color in container_colors:
-            container_pose = self.get_random_pose(env, container_size)
-            env.add_object(container_urdf, container_pose, color=utils.COLORS[color])
-            container_poses.append(container_pose)
-
-        # Add blocks.
-        block_size = (0.04, 0.04, 0.04)
-        block_urdf = 'block/block.urdf'
-        block_colors = ['red', 'red', 'blue', 'blue', 'green', 'green']
-        blocks = []
-        for color in block_colors:
-            block_pose = self.get_random_pose(env, block_size)
-            block_id = env.add_object(block_urdf, block_pose, color=utils.COLORS[color])
-            blocks.append(block_id)
-
-        # Goal: each block is in a container of the same color.
-        for i in range(len(blocks)):
-            self.add_goal(objs=[blocks[i]], matches=np.ones((1, 1)), targ_poses=[container_poses[i//2]], replace=False,
-                          rotations=True, metric='pose', params=None, step_max_reward=1/len(blocks), language_goal=self.lang_template)
\ No newline at end of file
diff --git a/spaces/Gen-Sim/Gen-Sim/scripts/metascripts/train10_cliport_indomain.sh b/spaces/Gen-Sim/Gen-Sim/scripts/metascripts/train10_cliport_indomain.sh
deleted file mode 100644
index 335be9efaf9c529a918ada89e5e1c9bec3eda79b..0000000000000000000000000000000000000000
--- a/spaces/Gen-Sim/Gen-Sim/scripts/metascripts/train10_cliport_indomain.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-#SBATCH -c 10
-#SBATCH -n 1
-#SBATCH -o logs/%j.out
-#SBATCH --exclusive
-STEPS=${1-'50000'}
-
-
-sh scripts/traintest_scripts/train_test_multi_task_indistribution.sh data \
-"[align-rope,sweeping-piles,align-box-corner,towers-of-hanoi-seq-seen-colors,assembling-kits-seq-seen-colors,block-insertion,palletizing-boxes,place-red-in-green,manipulating-rope,packing-boxes]" \
- cliport10_task_indomain $STEPS
-
diff --git a/spaces/GeorgeOrville/bingo/src/lib/hooks/chat-history.ts b/spaces/GeorgeOrville/bingo/src/lib/hooks/chat-history.ts
deleted file mode 100644
index c6fbf3fecfa86fe553f56acc8253236b8f22a775..0000000000000000000000000000000000000000
--- a/spaces/GeorgeOrville/bingo/src/lib/hooks/chat-history.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import { zip } from 'lodash-es'
-import { ChatMessageModel, BotId } from '@/lib/bots/bing/types'
-import { Storage } from '../storage'
-
-/**
- * conversations:$botId => Conversation[]
- * conversation:$botId:$cid:messages => ChatMessageModel[]
- */
-
-interface Conversation {
-  id: string
-  createdAt: number
-}
-
-type ConversationWithMessages = Conversation & { messages: ChatMessageModel[] }
-
-async function loadHistoryConversations(botId: BotId): Promise<Conversation[]> {
-  const key = `conversations:${botId}`
-  const { [key]: value } = await Storage.get(key)
-  return value || []
-}
-
-async function deleteHistoryConversation(botId: BotId, cid: string) {
-  const conversations = await loadHistoryConversations(botId)
-  const newConversations = conversations.filter((c) => c.id !== cid)
-  await Storage.set({ [`conversations:${botId}`]: newConversations })
-}
-
-async function loadConversationMessages(botId: BotId, cid: string): Promise<ChatMessageModel[]> {
-  const key = `conversation:${botId}:${cid}:messages`
-  const { [key]: value } = await Storage.get(key)
-  return value || []
-}
-
-export async function setConversationMessages(botId: BotId, cid: string, messages: ChatMessageModel[]) {
-  const conversations = await loadHistoryConversations(botId)
-  if (!conversations.some((c) => c.id === cid)) {
-    conversations.unshift({ id: cid, createdAt: Date.now() })
-    await Storage.set({ [`conversations:${botId}`]: conversations })
-  }
-  const key = `conversation:${botId}:${cid}:messages`
-  await Storage.set({ [key]: messages })
-}
-
-export async function loadHistoryMessages(botId: BotId): Promise<ConversationWithMessages[]> {
-  const conversations = await loadHistoryConversations(botId)
-  const messagesList = await Promise.all(conversations.map((c) => loadConversationMessages(botId, c.id)))
-  return zip(conversations, messagesList).map(([c, messages]) => ({
-    id: c!.id,
-    createdAt: c!.createdAt,
-    messages: messages!,
-  }))
-}
-
-export async function deleteHistoryMessage(botId: BotId, conversationId: string, messageId: string) {
-  const messages = await loadConversationMessages(botId, conversationId)
-  const newMessages = messages.filter((m) => m.id !== messageId)
-  await setConversationMessages(botId, conversationId, newMessages)
-  if (!newMessages.length) {
-    await deleteHistoryConversation(botId, conversationId)
-  }
-}
diff --git a/spaces/Gna1L/jonatasgrosman-wav2vec2-large-xlsr-53-english/app.py b/spaces/Gna1L/jonatasgrosman-wav2vec2-large-xlsr-53-english/app.py
deleted file mode 100644
index f7bc16986ba92aee8660a44201cba56f67447114..0000000000000000000000000000000000000000
--- a/spaces/Gna1L/jonatasgrosman-wav2vec2-large-xlsr-53-english/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/jonatasgrosman/wav2vec2-large-xlsr-53-english").launch()
\ No newline at end of file
diff --git a/spaces/Gradio-Blocks/ViTPose/README.md b/spaces/Gradio-Blocks/ViTPose/README.md
deleted file mode 100644
index ca3ee510466830a03ef9b2e69c46c74213d1a60f..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/ViTPose/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: ViTPose
-emoji: 📊
-colorFrom: yellow
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.36.1
-app_file: app.py
-pinned: false
-suggested_hardware: t4-small
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
-
-https://arxiv.org/abs/2204.12484
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/vfnet/README.md b/spaces/Gradio-Blocks/uniformer_image_detection/configs/vfnet/README.md
deleted file mode 100644
index d1a94d155149250e76d922185763c13d64509a62..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/vfnet/README.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# VarifocalNet: An IoU-aware Dense Object Detector
-
-## Introduction
-
-[ALGORITHM]
-
-**VarifocalNet (VFNet)** learns to predict the IoU-aware classification score which mixes the object presence confidence and localization accuracy together as the detection score for a bounding box. The learning is supervised by the proposed Varifocal Loss (VFL), based on a new star-shaped bounding box feature representation (the features at nine yellow sampling points). Given the new representation, the object localization accuracy is further improved by refining the initially regressed bounding box. The full paper is available at: [https://arxiv.org/abs/2008.13367](https://arxiv.org/abs/2008.13367).
-
-<div align="center">
-  <img src="https://user-images.githubusercontent.com/9102141/97464778-4b9ab000-197c-11eb-9283-ab2907ee0252.png" width="600px" />
-  <p>Learning to Predict the IoU-aware Classification Score.</p>
-</div>
-
-## Citing VarifocalNet
-
-```latex
-@article{zhang2020varifocalnet,
-  title={VarifocalNet: An IoU-aware Dense Object Detector},
-  author={Zhang, Haoyang and Wang, Ying and Dayoub, Feras and S{\"u}nderhauf, Niko},
-  journal={arXiv preprint arXiv:2008.13367},
-  year={2020}
-}
-```
-
-## Results and Models
-
-| Backbone     | Style     | DCN     | MS train | Lr schd |Inf time (fps) | box AP (val) | box AP (test-dev) | Config | Download |
-|:------------:|:---------:|:-------:|:--------:|:-------:|:-------------:|:------------:|:-----------------:|:------:|:--------:|
-| R-50         | pytorch   | N       | N        | 1x      | -          | 41.6         | 41.6              | [config](https://github.com/open-mmlab/mmdetection/blob/master/configs/vfnet_r50_fpn_1x_coco.py) |  [model](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_1x_coco/vfnet_r50_fpn_1x_coco_20201027-38db6f58.pth) &#124; [log](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_1x_coco/vfnet_r50_fpn_1x_coco.json)|
-| R-50         | pytorch   | N       | Y        | 2x      | -          | 44.5         | 44.8              | [config](https://github.com/open-mmlab/mmdetection/blob/master/configs/vfnet_r50_fpn_mstrain_2x_coco.py) | [model](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_mstrain_2x_coco/vfnet_r50_fpn_mstrain_2x_coco_20201027-7cc75bd2.pth) &#124; [log](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_mstrain_2x_coco/vfnet_r50_fpn_mstrain_2x_coco.json)|
-| R-50         | pytorch   | Y       | Y        | 2x      | -          | 47.8         | 48.0              | [config](https://github.com/open-mmlab/mmdetection/blob/master/configs/vfnet_r50_fpn_mdconv_c3-c5_mstrain_2x_coco.py) | [model](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_r50_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-6879c318.pth) &#124; [log](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_r50_fpn_mdconv_c3-c5_mstrain_2x_coco.json)|
-| R-101        | pytorch   | N       | N        | 1x      | -          | 43.0         | 43.6              | [config](https://github.com/open-mmlab/mmdetection/blob/master/configs/vfnet_r101_fpn_1x_coco.py) | [model](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_1x_coco/vfnet_r101_fpn_1x_coco_20201027pth-c831ece7.pth) &#124; [log](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_1x_coco/vfnet_r101_fpn_1x_coco.json)|
-| R-101        | pytorch   | N       | Y        | 2x      | -          | 46.2         | 46.7              | [config](https://github.com/open-mmlab/mmdetection/blob/master/configs/vfnet_r101_fpn_mstrain_2x_coco.py) | [model](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_mstrain_2x_coco/vfnet_r101_fpn_mstrain_2x_coco_20201027pth-4a5d53f1.pth) &#124; [log](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_mstrain_2x_coco/vfnet_r101_fpn_mstrain_2x_coco.json)|
-| R-101        | pytorch   | Y       | Y        | 2x      | -          | 49.0         | 49.2              | [config](https://github.com/open-mmlab/mmdetection/blob/master/configs/vfnet_r101_fpn_mdconv_c3-c5_mstrain_2x_coco.py) | [model](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_r101_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-7729adb5.pth) &#124; [log](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_r101_fpn_mdconv_c3-c5_mstrain_2x_coco.json)|
-| X-101-32x4d  | pytorch   | Y       | Y        | 2x      | -          | 49.7         | 50.0              | [config](https://github.com/open-mmlab/mmdetection/blob/master/configs/vfnet_x101_32x4d_fpn_mdconv_c3-c5_mstrain_2x_coco.py) | [model](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_x101_32x4d_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_x101_32x4d_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-d300a6fc.pth) &#124; [log](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_x101_32x4d_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_x101_32x4d_fpn_mdconv_c3-c5_mstrain_2x_coco.json)|
-| X-101-64x4d  | pytorch   | Y       | Y        | 2x      |  -         | 50.4         | 50.8              | [config](https://github.com/open-mmlab/mmdetection/blob/master/configs/vfnet_x101_64x4d_fpn_mdconv_c3-c5_mstrain_2x_coco.py) | [model](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_x101_64x4d_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_x101_64x4d_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-b5f6da5e.pth) &#124; [log](https://openmmlab.oss-cn-hangzhou.aliyuncs.com/mmdetection/v2.0/vfnet/vfnet_x101_64x4d_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_x101_64x4d_fpn_mdconv_c3-c5_mstrain_2x_coco.json)|
-
-**Notes:**
-
-- The MS-train scale range is 1333x[480:960] (`range` mode) and the inference scale keeps 1333x800.
-- DCN means using `DCNv2` in both backbone and head.
-- Inference time will be updated soon.
-- More results and pre-trained models can be found in [VarifocalNet-Github](https://github.com/hyz-xmaster/VarifocalNet)
diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/exp/upernet_global_base/config.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/exp/upernet_global_base/config.py
deleted file mode 100644
index a309591da09653835292e40c3bf7348f2d46181f..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_segmentation/exp/upernet_global_base/config.py
+++ /dev/null
@@ -1,40 +0,0 @@
-_base_ = [
-    '../../configs/_base_/models/upernet_uniformer.py', 
-    '../../configs/_base_/datasets/ade20k.py',
-    '../../configs/_base_/default_runtime.py', 
-    '../../configs/_base_/schedules/schedule_160k.py'
-]
-model = dict(
-    backbone=dict(
-        type='UniFormer',
-        embed_dim=[64, 128, 320, 512],
-        layers=[5, 8, 20, 7],
-        head_dim=64,
-        drop_path_rate=0.4,
-        use_checkpoint=True,
-        checkpoint_num=[0, 0, 2, 0],
-        windows=False,
-        hybrid=False
-    ),
-    decode_head=dict(
-        in_channels=[64, 128, 320, 512],
-        num_classes=150
-    ),
-    auxiliary_head=dict(
-        in_channels=320,
-        num_classes=150
-    ))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm in backbone
-optimizer = dict(_delete_=True, type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01,
-                 paramwise_cfg=dict(custom_keys={'absolute_pos_embed': dict(decay_mult=0.),
-                                                 'relative_position_bias_table': dict(decay_mult=0.),
-                                                 'norm': dict(decay_mult=0.)}))
-
-lr_config = dict(_delete_=True, policy='poly',
-                 warmup='linear',
-                 warmup_iters=1500,
-                 warmup_ratio=1e-6,
-                 power=1.0, min_lr=0.0, by_epoch=False)
-
-data=dict(samples_per_gpu=2)
\ No newline at end of file
diff --git a/spaces/GrandaddyShmax/MusicGen_Plus_hfv2/tests/common_utils/__init__.py b/spaces/GrandaddyShmax/MusicGen_Plus_hfv2/tests/common_utils/__init__.py
deleted file mode 100644
index 74ffcfef96fec35c99b2a1a053a61f44f7a8bbe9..0000000000000000000000000000000000000000
--- a/spaces/GrandaddyShmax/MusicGen_Plus_hfv2/tests/common_utils/__init__.py
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-# flake8: noqa
-from .temp_utils import TempDirMixin
-from .wav_utils import get_batch_white_noise, get_white_noise, save_wav
diff --git a/spaces/GroveStreet/GTA_SOVITS/modules/ddsp.py b/spaces/GroveStreet/GTA_SOVITS/modules/ddsp.py
deleted file mode 100644
index b09ac5c5c19d165e75e1780877a857be8c104ed7..0000000000000000000000000000000000000000
--- a/spaces/GroveStreet/GTA_SOVITS/modules/ddsp.py
+++ /dev/null
@@ -1,190 +0,0 @@
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-import torch.fft as fft
-import numpy as np
-import librosa as li
-import math
-from scipy.signal import get_window
-
-
-def safe_log(x):
-    return torch.log(x + 1e-7)
-
-
-@torch.no_grad()
-def mean_std_loudness(dataset):
-    mean = 0
-    std = 0
-    n = 0
-    for _, _, l in dataset:
-        n += 1
-        mean += (l.mean().item() - mean) / n
-        std += (l.std().item() - std) / n
-    return mean, std
-
-
-def multiscale_fft(signal, scales, overlap):
-    stfts = []
-    for s in scales:
-        S = torch.stft(
-            signal,
-            s,
-            int(s * (1 - overlap)),
-            s,
-            torch.hann_window(s).to(signal),
-            True,
-            normalized=True,
-            return_complex=True,
-        ).abs()
-        stfts.append(S)
-    return stfts
-
-
-def resample(x, factor: int):
-    batch, frame, channel = x.shape
-    x = x.permute(0, 2, 1).reshape(batch * channel, 1, frame)
-
-    window = torch.hann_window(
-        factor * 2,
-        dtype=x.dtype,
-        device=x.device,
-    ).reshape(1, 1, -1)
-    y = torch.zeros(x.shape[0], x.shape[1], factor * x.shape[2]).to(x)
-    y[..., ::factor] = x
-    y[..., -1:] = x[..., -1:]
-    y = torch.nn.functional.pad(y, [factor, factor])
-    y = torch.nn.functional.conv1d(y, window)[..., :-1]
-
-    y = y.reshape(batch, channel, factor * frame).permute(0, 2, 1)
-
-    return y
-
-
-def upsample(signal, factor):
-    signal = signal.permute(0, 2, 1)
-    signal = nn.functional.interpolate(signal, size=signal.shape[-1] * factor)
-    return signal.permute(0, 2, 1)
-
-
-def remove_above_nyquist(amplitudes, pitch, sampling_rate):
-    n_harm = amplitudes.shape[-1]
-    pitches = pitch * torch.arange(1, n_harm + 1).to(pitch)
-    aa = (pitches < sampling_rate / 2).float() + 1e-4
-    return amplitudes * aa
-
-
-def scale_function(x):
-    return 2 * torch.sigmoid(x) ** (math.log(10)) + 1e-7
-
-
-def extract_loudness(signal, sampling_rate, block_size, n_fft=2048):
-    S = li.stft(
-        signal,
-        n_fft=n_fft,
-        hop_length=block_size,
-        win_length=n_fft,
-        center=True,
-    )
-    S = np.log(abs(S) + 1e-7)
-    f = li.fft_frequencies(sampling_rate, n_fft)
-    a_weight = li.A_weighting(f)
-
-    S = S + a_weight.reshape(-1, 1)
-
-    S = np.mean(S, 0)[..., :-1]
-
-    return S
-
-
-def extract_pitch(signal, sampling_rate, block_size):
-    length = signal.shape[-1] // block_size
-    f0 = crepe.predict(
-        signal,
-        sampling_rate,
-        step_size=int(1000 * block_size / sampling_rate),
-        verbose=1,
-        center=True,
-        viterbi=True,
-    )
-    f0 = f0[1].reshape(-1)[:-1]
-
-    if f0.shape[-1] != length:
-        f0 = np.interp(
-            np.linspace(0, 1, length, endpoint=False),
-            np.linspace(0, 1, f0.shape[-1], endpoint=False),
-            f0,
-        )
-
-    return f0
-
-
-def mlp(in_size, hidden_size, n_layers):
-    channels = [in_size] + (n_layers) * [hidden_size]
-    net = []
-    for i in range(n_layers):
-        net.append(nn.Linear(channels[i], channels[i + 1]))
-        net.append(nn.LayerNorm(channels[i + 1]))
-        net.append(nn.LeakyReLU())
-    return nn.Sequential(*net)
-
-
-def gru(n_input, hidden_size):
-    return nn.GRU(n_input * hidden_size, hidden_size, batch_first=True)
-
-
-def harmonic_synth(pitch, amplitudes, sampling_rate):
-    n_harmonic = amplitudes.shape[-1]
-    omega = torch.cumsum(2 * math.pi * pitch / sampling_rate, 1)
-    omegas = omega * torch.arange(1, n_harmonic + 1).to(omega)
-    signal = (torch.sin(omegas) * amplitudes).sum(-1, keepdim=True)
-    return signal
-
-
-def amp_to_impulse_response(amp, target_size):
-    amp = torch.stack([amp, torch.zeros_like(amp)], -1)
-    amp = torch.view_as_complex(amp)
-    amp = fft.irfft(amp)
-
-    filter_size = amp.shape[-1]
-
-    amp = torch.roll(amp, filter_size // 2, -1)
-    win = torch.hann_window(filter_size, dtype=amp.dtype, device=amp.device)
-
-    amp = amp * win
-
-    amp = nn.functional.pad(amp, (0, int(target_size) - int(filter_size)))
-    amp = torch.roll(amp, -filter_size // 2, -1)
-
-    return amp
-
-
-def fft_convolve(signal, kernel):
-    signal = nn.functional.pad(signal, (0, signal.shape[-1]))
-    kernel = nn.functional.pad(kernel, (kernel.shape[-1], 0))
-
-    output = fft.irfft(fft.rfft(signal) * fft.rfft(kernel))
-    output = output[..., output.shape[-1] // 2:]
-
-    return output
-
-
-def init_kernels(win_len, win_inc, fft_len, win_type=None, invers=False):
-    if win_type == 'None' or win_type is None:
-        window = np.ones(win_len)
-    else:
-        window = get_window(win_type, win_len, fftbins=True)  # **0.5
-
-    N = fft_len
-    fourier_basis = np.fft.rfft(np.eye(N))[:win_len]
-    real_kernel = np.real(fourier_basis)
-    imag_kernel = np.imag(fourier_basis)
-    kernel = np.concatenate([real_kernel, imag_kernel], 1).T
-
-    if invers:
-        kernel = np.linalg.pinv(kernel).T
-
-    kernel = kernel * window
-    kernel = kernel[:, None, :]
-    return torch.from_numpy(kernel.astype(np.float32)), torch.from_numpy(window[None, :, None].astype(np.float32))
-
diff --git a/spaces/Guknadereve/stabilityai-stable-diffusion-2-1/README.md b/spaces/Guknadereve/stabilityai-stable-diffusion-2-1/README.md
deleted file mode 100644
index 16c98a03f4365ea718512c39ac136ed433ce7057..0000000000000000000000000000000000000000
--- a/spaces/Guknadereve/stabilityai-stable-diffusion-2-1/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Stabilityai Stable Diffusion 2 1
-emoji: 👀
-colorFrom: red
-colorTo: green
-sdk: gradio
-sdk_version: 3.14.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/HCMUT-GraduateThesis-HNTThinh/rgbdsod-multimae-demo/lib/multi_depth_model_woauxi.py b/spaces/HCMUT-GraduateThesis-HNTThinh/rgbdsod-multimae-demo/lib/multi_depth_model_woauxi.py
deleted file mode 100644
index 7b04834861722d439eadf04f42ebd024385b1622..0000000000000000000000000000000000000000
--- a/spaces/HCMUT-GraduateThesis-HNTThinh/rgbdsod-multimae-demo/lib/multi_depth_model_woauxi.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import torch
-from torch import Tensor, nn
-
-from lib import network_auxi as network
-from lib.net_tools import get_func
-
-class RelDepthModel(nn.Module):
-    def __init__(self, backbone: str = 'resnet50'):
-        super(RelDepthModel, self).__init__()
-        if backbone == 'resnet50':
-            encoder = 'resnet50_stride32'
-        elif backbone == 'resnext101':
-            encoder = 'resnext101_stride32x8d'
-        self.depth_model = DepthModel(encoder)
-
-    def inference(self, rgb: Tensor) -> Tensor:
-        with torch.no_grad():
-            depth: Tensor = self.depth_model(rgb)
-            pred_depth_out = depth - depth.min() + 0.01
-            return pred_depth_out
-
-
-class DepthModel(nn.Module):
-    def __init__(self, encoder: str):
-        super(DepthModel, self).__init__()
-        backbone = network.__name__.split('.')[-1] + '.' + encoder
-        self.encoder_modules = get_func(backbone)()
-        self.decoder_modules = network.Decoder()
-
-    def forward(self, x: Tensor) -> Tensor:
-        lateral_out = self.encoder_modules(x)
-        out_logit = self.decoder_modules(lateral_out)
-        return out_logit
\ No newline at end of file
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/backtranslation/sacrebleu.sh b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/backtranslation/sacrebleu.sh
deleted file mode 100644
index a70da23f48e2699297799611412783d4560dc45a..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/backtranslation/sacrebleu.sh
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/bin/bash
-
-if [ $# -ne 5 ]; then
-    echo "usage: $0 [dataset=wmt14/full] [langpair=en-de] [databin] [bpecode] [model]"
-    exit
-fi
-
-
-DATASET=$1
-LANGPAIR=$2
-DATABIN=$3
-BPECODE=$4
-MODEL=$5
-
-SRCLANG=$(echo $LANGPAIR | cut -d '-' -f 1)
-TGTLANG=$(echo $LANGPAIR | cut -d '-' -f 2)
-
-
-BPEROOT=examples/backtranslation/subword-nmt/subword_nmt
-if [ ! -e $BPEROOT ]; then
-    BPEROOT=subword-nmt/subword_nmt
-    if [ ! -e $BPEROOT ]; then
-        echo 'Cloning Subword NMT repository (for BPE pre-processing)...'
-        git clone https://github.com/rsennrich/subword-nmt.git
-    fi
-fi
-
-
-sacrebleu -t $DATASET -l $LANGPAIR --echo src \
-| sacremoses tokenize -a -l $SRCLANG -q \
-| python $BPEROOT/apply_bpe.py -c $BPECODE \
-| fairseq-interactive $DATABIN --path $MODEL \
-    -s $SRCLANG -t $TGTLANG \
-    --beam 5 --remove-bpe --buffer-size 1024 --max-tokens 8000 \
-| grep ^H- | cut -f 3- \
-| sacremoses detokenize -l $TGTLANG -q \
-| sacrebleu -t $DATASET -l $LANGPAIR
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/multilingual/data_scripts/download_wmt20.sh b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/multilingual/data_scripts/download_wmt20.sh
deleted file mode 100644
index 31cd5c76b75081331ae03c5ea70ea7ddebaa06e1..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/multilingual/data_scripts/download_wmt20.sh
+++ /dev/null
@@ -1,547 +0,0 @@
-#!/bin/bash
-# Copyright (c) Facebook, Inc. and its affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-if [ -z $WORKDIR_ROOT ] ;
-then
-        echo "please specify your working directory root in environment variable WORKDIR_ROOT. Exitting..."
-        exit
-fi
-
-
-
-set -x -e
-
-# TODO update the workdir and dest dir name
-# put fasttext model
-WORKDIR=$WORKDIR_ROOT
-# put intermediate files
-TMP_DIR=$WORKDIR_ROOT/tmp/tmp_wmt20_lowres_download
-# output {train,valid,test} files to dest
-DEST=$WORKDIR_ROOT/ML50/raw
-
-UTILS=$PWD/utils
-
-# per dataset locations
-COMMONCRAWL_DIR=$TMP_DIR/commoncrawl
-YANDEX_CORPUS=$WORKDIR_ROOT/wmt20/official/ru/yandex/1mcorpus.zip
-# unzipped
-CZENG_CORPUS=$WORKDIR_ROOT/wmt20/official/cs/czeng/czeng20-train
-CCMT_DIR=$WORKDIR_ROOT/wmt20/official/zh/ccmt/parallel
-
-download_and_select() {
-  SUBFOLDER=$1
-  URL=$2
-  UNCOMPRESS_CMD=$3
-  LANG=$4
-  INPUT_FILEPATH=$5
-  if [[ $# -gt 5 ]]; then
-    LANG_COL=$6
-    EN_COL=$7
-  fi
-
-  mkdir -p $SUBFOLDER
-  cd $SUBFOLDER
-  wget -nc --content-disposition $URL
-  $UNCOMPRESS_CMD
-
-  if [[ $# -gt 5 ]]; then
-    cut -f$LANG_COL $INPUT_FILEPATH > $INPUT_FILEPATH.$LANG
-    cut -f$EN_COL $INPUT_FILEPATH > $INPUT_FILEPATH.en
-  fi
-  cd ..
-
-  ln -sf $SUBFOLDER/$INPUT_FILEPATH.$LANG $SUBFOLDER.$LANG
-  ln -sf $SUBFOLDER/$INPUT_FILEPATH.en $SUBFOLDER.en
-}
-
-prepare_lid() {
-  pip install fasttext
-
-  # TODO specify global workdir
-  MODEL=$WORKDIR/fasttext/lid.176.bin
-  LID_MULTI=$UTILS/fasttext_multi_filter.py
-
-  if [ ! -f "$MODEL" ]; then
-    echo "downloading fasttext lid model..."
-    mkdir -p $WORKDIR/fasttext
-    wget -nc https://dl.fbaipublicfiles.com/fasttext/supervised-models/lid.176.bin -O $MODEL
-  fi
-}
-
-prepare_moses() {
-  pushd $UTILS
-  echo 'Cloning Moses github repository (for tokenization scripts)...'
-  git clone https://github.com/moses-smt/mosesdecoder.git  
-  popd
-}
-
-lid_filter() {
-  # TODO specify global workdir
-  MODEL=$WORKDIR/fasttext/lid.176.bin
-  LID_MULTI=$UTILS/fasttext_multi_filter.py
-
-  prepare_lid
-
-  SRC=$1
-  SRC_FILE=$2
-  SRC_OUTPUT=$3
-  TGT=$4
-  TGT_FILE=$5
-  TGT_OUTPUT=$6
-  python $LID_MULTI --model $MODEL --inputs $SRC_FILE $TGT_FILE --langs $SRC $TGT --outputs $SRC_OUTPUT $TGT_OUTPUT
-}
-
-prepare_ja_ted() {
-  mkdir -p ted
-  cd ted
-
-  wget -nc https://wit3.fbk.eu/archive/2017-01-trnted//texts/en/ja/en-ja.tgz
-  tar -zxvf en-ja.tgz
-  cat en-ja/train.tags.en-ja.en | grep -v -P "^[ ]*\<" | sed 's/^[ \t]*//g' | sed 's/[ \t]*$//g' > en-ja/train.en-ja.en
-  cat en-ja/train.tags.en-ja.ja | grep -v -P "^[ ]*\<" | sed 's/^[ \t]*//g' | sed 's/[ \t]*$//g' > en-ja/train.en-ja.ja
-
-  cd ..
-  ln -sf ted/en-ja/train.en-ja.ja ted.ja
-  ln -sf ted/en-ja/train.en-ja.en ted.en
-}
-
-prepare_ja() {
-  OUTPUT_DIR=$TMP_DIR/ja
-  mkdir -p $OUTPUT_DIR
-  cd $OUTPUT_DIR
-
-  download_and_select paracrawl "http://www.kecl.ntt.co.jp/icl/lirg/jparacrawl/release/2.0/bitext/en-ja.tar.gz" "tar -zxvf en-ja.tar.gz" ja en-ja/en-ja.bicleaner05.txt 4 3 &
-  download_and_select newscommentary "http://data.statmt.org/news-commentary/v15/training/news-commentary-v15.en-ja.tsv.gz" "gunzip -f news-commentary-v15.en-ja.tsv.gz" ja news-commentary-v15.en-ja.tsv 2 1 &
-  download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.ja-en.tsv.gz" "gunzip -f wikititles-v2.ja-en.tsv.gz" ja wikititles-v2.ja-en.tsv 1 2 &
-  download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.en-ja.langid.tsv.gz" "gunzip -f WikiMatrix.v1.en-ja.langid.tsv.gz" ja WikiMatrix.v1.en-ja.langid.tsv 3 2 &
-  download_and_select subtitle "https://nlp.stanford.edu/projects/jesc/data/split.tar.gz" "tar -zxvf split.tar.gz" ja split/train 2 1 &
-  download_and_select kftt "http://www.phontron.com/kftt/download/kftt-data-1.0.tar.gz" "tar -zxvf kftt-data-1.0.tar.gz" ja kftt-data-1.0/data/orig/kyoto-train &
-
-  prepare_ja_ted &
-
-  # ted data needs to 
-
-  wait
-
-  # remove previous results
-  rm -f all.??
-  find ./ -maxdepth 1 -name "*.ja" | sort -V | xargs cat > all.ja
-  find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en
-  lid_filter ja all.ja $DEST/train.ja_XX-en_XX.ja_XX en all.en $DEST/train.ja_XX-en_XX.en_XX
-}
-
-prepare_ta() {
-  OUTPUT_DIR=$TMP_DIR/ta
-  mkdir -p $OUTPUT_DIR
-  cd $OUTPUT_DIR
-
-  download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.ta-en.tsv.gz" "gunzip -f wikititles-v2.ta-en.tsv.gz" ta wikititles-v2.ta-en.tsv 1 2 &
-  download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.en-ta.langid.tsv.gz" "gunzip -f WikiMatrix.v1.en-ta.langid.tsv.gz" ta WikiMatrix.v1.en-ta.langid.tsv 3 2 &
-  download_and_select pmindia "http://data.statmt.org/pmindia/v1/parallel/pmindia.v1.ta-en.tsv" "" ta pmindia.v1.ta-en.tsv 2 1 &
-  download_and_select tanzil "https://object.pouta.csc.fi/OPUS-Tanzil/v1/moses/en-ta.txt.zip" "unzip en-ta.txt.zip" ta Tanzil.en-ta &
-  download_and_select pib "http://preon.iiit.ac.in/~jerin/resources/datasets/pib-v0.tar" "tar -xvf pib-v0.tar" ta pib/en-ta/train &
-  download_and_select mkb "http://preon.iiit.ac.in/~jerin/resources/datasets/mkb-v0.tar" "tar -xvf mkb-v0.tar" ta mkb/en-ta/mkb &
-  download_and_select ufal "http://ufal.mff.cuni.cz/~ramasamy/parallel/data/v2/en-ta-parallel-v2.tar.gz" "tar -zxvf en-ta-parallel-v2.tar.gz" ta en-ta-parallel-v2/corpus.bcn.train &
-
-  wait
-
-  # need special handling for nlpc
-  mkdir -p nlpc
-  cd nlpc
-  wget -nc https://raw.githubusercontent.com/nlpc-uom/English-Tamil-Parallel-Corpus/master/En-Ta%20Corpus/En-Ta%20English.txt
-  wget -nc https://github.com/nlpc-uom/English-Tamil-Parallel-Corpus/raw/master/En-Ta%20Corpus/En-Ta%20Tamil.txt
-  tail -n +4 "En-Ta English.txt" > en-ta.en
-  tail -n +4 "En-Ta Tamil.txt" > en-ta.ta
-  cd ..
-  ln -sf nlpc/en-ta.en nlpc.en
-  ln -sf nlpc/en-ta.ta nlpc.ta
-
-  # remove previous results
-  rm -f all.??
-  find ./ -maxdepth 1 -name "*.ta" | sort -V | xargs cat > all.ta
-  find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en
-  lid_filter ta all.ta $DEST/train.ta_IN-en_XX.ta_IN en all.en $DEST/train.ta_IN-en_XX.en_XX
-}
-
-prepare_iu() {
-  OUTPUT_DIR=$TMP_DIR/iu
-  mkdir -p $OUTPUT_DIR
-  cd $OUTPUT_DIR
-  
-  download_and_select nh "https://nrc-digital-repository.canada.ca/eng/view/dataset/?id=c7e34fa7-7629-43c2-bd6d-19b32bf64f60" "tar -zxvf Nunavut-Hansard-Inuktitut-English-Parallel-Corpus-3.0.1.tgz" iu Nunavut-Hansard-Inuktitut-English-Parallel-Corpus-3.0/NunavutHansard > /dev/null &
-  download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.iu-en.tsv.gz" "gunzip -f wikititles-v2.iu-en.tsv.gz" iu wikititles-v2.iu-en.tsv 1 2 &
-
-  wait
-
-  # remove previous results
-  rm -f all.??
-  find ./ -maxdepth 1 -name "*.iu" | sort -V | xargs cat | nh/Nunavut-Hansard-Inuktitut-English-Parallel-Corpus-3.0/scripts/normalize-iu-spelling.pl > all.iu
-  find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en
-  paste all.iu all.en | awk -F $'\t' '$1!=""&&$2!=""' > all.iuen
-  cut -f1 all.iuen > $DEST/train.iu_CA-en_XX.iu_CA
-  cut -f2 all.iuen > $DEST/train.iu_CA-en_XX.en_XX
-}
-
-prepare_km() {
-  OUTPUT_DIR=$TMP_DIR/km
-  mkdir -p $OUTPUT_DIR
-  cd $OUTPUT_DIR
-
-  download_and_select paracrawl "http://data.statmt.org/wmt20/translation-task/ps-km/wmt20-sent.en-km.xz" "unxz wmt20-sent.en-km.zx" km wmt20-sent.en-km 2 1 &
-
-  # km-parallel has multiple sets, concat all of them together
-  mkdir -p opus
-  cd opus
-  wget -nc "http://data.statmt.org/wmt20/translation-task/ps-km/km-parallel.tgz"
-  tar -zxvf km-parallel.tgz
-  find ./km-parallel -maxdepth 1 -name "*.km" | sort -V | xargs cat > opus.km
-  find ./km-parallel -maxdepth 1 -name "*.en" | sort -V | xargs cat > opus.en
-  cd ..
-  ln -sf opus/opus.km .
-  ln -sf opus/opus.en .
-
-  wait
-
-  # remove previous results
-  rm -f all.??
-  find ./ -maxdepth 1 -name "*.km" | sort -V | xargs cat > all.km
-  find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en
-  lid_filter km all.km $DEST/train.km_KH-en_XX.km_KH en all.en $DEST/train.km_KH-en_XX.en_XX
-}
-
-prepare_ps() {
-  OUTPUT_DIR=$TMP_DIR/ps
-  mkdir -p $OUTPUT_DIR
-  cd $OUTPUT_DIR
-
-  download_and_select paracrawl "http://data.statmt.org/wmt20/translation-task/ps-km/wmt20-sent.en-ps.xz" "unxz wmt20-sent.en-ps.xz" ps wmt20-sent.en-ps 2 1 &
-  download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.ps-en.tsv.gz" "gunzip -f wikititles-v2.ps-en.tsv.gz" ps wikititles-v2.ps-en.tsv 1 2 &
-  # ps-parallel has multiple sets, concat all of them together
-  mkdir -p opus
-  cd opus
-  wget -nc "http://data.statmt.org/wmt20/translation-task/ps-km/ps-parallel.tgz"
-  tar -zxvf ps-parallel.tgz
-  find ./ps-parallel -maxdepth 1 -name "*.ps" | sort -V | xargs cat > opus.ps
-  find ./ps-parallel -maxdepth 1 -name "*.en" | sort -V | xargs cat > opus.en
-  cd ..
-  ln -sf opus/opus.ps opus.ps
-  ln -sf opus/opus.en opus.en
-
-  wait
-
-  # remove previous results
-  rm -f all.??
-  find ./ -maxdepth 1 -name "*.ps" | sort -V | xargs cat > all.ps
-  find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en
-  lid_filter ps all.ps $DEST/train.ps_AF-en_XX.ps_AF en all.en $DEST/train.ps_AF-en_XX.en_XX
-}
-
-download_commoncrawl() {
-  mkdir -p $COMMONCRAWL_DIR
-  cd $COMMONCRAWL_DIR
-
-  wget -nc "http://www.statmt.org/wmt13/training-parallel-commoncrawl.tgz"
-  tar -zxvf training-parallel-commoncrawl.tgz
-}
-link_commoncrawl() {
-  LANG=$1
-  ln -sf $COMMONCRAWL_DIR/commoncrawl.$LANG-en.en commoncrawl.en
-  ln -sf $COMMONCRAWL_DIR/commoncrawl.$LANG-en.$LANG commoncrawl.$LANG
-}
-
-strip_xlf() {
-  INPUT_FILE=$1
-  SRC=$2
-  TGT=$3
-  grep '<source xml:lang=' $INPUT_FILE | sed 's/^<[^<>]*>//g' | sed 's/<[^<>]*>$//g' > $INPUT_FILE.$SRC
-  grep '<target xml:lang=' $INPUT_FILE | sed 's/^<[^<>]*>//g' | sed 's/<[^<>]*>$//g' > $INPUT_FILE.$TGT
-}
-
-download_and_process_tilde() {
-  URL=$1
-  UNCOMPRESS_CMD=$2
-  FILENAME=$3
-  LANG=$4
-  PROCESS_CMD=$5
-
-  mkdir -p tilde
-  cd tilde
-  wget -nc $URL
-  $UNCOMPRESS_CMD
-  echo "executing cmd"
-  echo $PROCESS_CMD
-  $PROCESS_CMD
-  cd ..
-  ln -sf tilde/$FILENAME.$LANG tilde.$LANG
-  ln -sf tilde/$FILENAME.en tilde.en
-}
-
-prepare_cs() {
-  OUTPUT_DIR=$TMP_DIR/cs
-  mkdir -p $OUTPUT_DIR
-  cd $OUTPUT_DIR
-
-  #download_and_select europarl "http://www.statmt.org/europarl/v10/training/europarl-v10.cs-en.tsv.gz" "gunzip europarl-v10.cs-en.tsv.gz" cs europarl-v10.cs-en.tsv 1 2 &
-  #download_and_select paracrawl "https://s3.amazonaws.com/web-language-models/paracrawl/release5.1/en-cs.txt.gz" "gunzip en-cs.txt.gz" cs en-cs.txt 2 1 &
-  #link_commoncrawl cs
-  #download_and_select newscommentary "http://data.statmt.org/news-commentary/v15/training/news-commentary-v15.cs-en.tsv.gz" "gunzip news-commentary-v15.cs-en.tsv.gz" cs news-commentary-v15.cs-en.tsv 1 2 &
-  #download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.cs-en.tsv.gz" "gunzip wikititles-v2.cs-en.tsv.gz" cs wikititles-v2.cs-en.tsv 1 2 &
-  #download_and_process_tilde "http://data.statmt.org/wmt20/translation-task/rapid/RAPID_2019.cs-en.xlf.gz" "gunzip RAPID_2019.cs-en.xlf.gz" RAPID_2019.cs-en.xlf cs "strip_xlf RAPID_2019.cs-en.xlf cs en" &
-  #download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.cs-en.langid.tsv.gz" "gunzip WikiMatrix.v1.cs-en.langid.tsv.gz" cs WikiMatrix.v1.cs-en.langid.tsv 2 3 &
-
-  #wait
-
-  # remove previous results
-  #rm -f all.??
-  #find ./ -maxdepth 1 -name "*.cs" | sort -V | xargs cat > all.cs
-  #find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en
-  if [ -z $CZENG_CORPUS ] ;
-  then
-          echo "Please download CZENG_CORPUS manually and place them at $CZENG_CORPUS. Exitting..."
-          exit
-  fi  
-  cat $CZENG_CORPUS | sed '/^$/d' | cut -f5 > all.cs
-  cat $CZENG_CORPUS | sed '/^$/d' | cut -f6 > all.en
-
-  lid_filter cs all.cs $DEST/train.cs_CZ-en_XX.cs_CZ en all.en $DEST/train.cs_CZ-en_XX.en_XX
-}
-
-prepare_de() {
-  OUTPUT_DIR=$TMP_DIR/de
-  mkdir -p $OUTPUT_DIR
-  cd $OUTPUT_DIR
-
-  download_and_select europarl "http://www.statmt.org/europarl/v10/training/europarl-v10.de-en.tsv.gz" "gunzip europarl-v10.de-en.tsv.gz" de europarl-v10.de-en.tsv 1 2 &
-  download_and_select paracrawl "https://s3.amazonaws.com/web-language-models/paracrawl/release5.1/en-de.txt.gz"  "gunzip en-de.txt.gz" de en-de.txt 2 1 &
-  link_commoncrawl de
-  download_and_select newscommentary "http://data.statmt.org/news-commentary/v15/training/news-commentary-v15.de-en.tsv.gz" "gunzip news-commentary-v15.de-en.tsv.gz" de news-commentary-v15.de-en.tsv 1 2 &
-  download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.de-en.tsv.gz" "gunzip wikititles-v2.de-en.tsv.gz" de wikititles-v2.de-en.tsv 1 2 &
-  download_and_process_tilde "http://data.statmt.org/wmt20/translation-task/rapid/RAPID_2019.de-en.xlf.gz" "gunzip RAPID_2019.de-en.xlf.gz" RAPID_2019.de-en.xlf de "strip_xlf RAPID_2019.de-en.xlf de en" &
-  download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.de-en.langid.tsv.gz" "gunzip WikiMatrix.v1.de-en.langid.tsv.gz" de WikiMatrix.v1.de-en.langid.tsv 2 3 &
-
-  wait
-
-  # remove previous results
-  rm -f all.??
-  find ./ -maxdepth 1 -name "*.de" | sort -V | xargs cat > all.de
-  find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en
-  lid_filter de all.de $DEST/train.de_DE-en_XX.de_DE en all.en $DEST/train.de_DE-en_XX.en_XX
-}
-
-prepare_tmx() {
-  TMX_FILE=$1
-  git clone https://github.com/amake/TMX2Corpus $UTILS/tmx2corpus
-  pip install tinysegmenter
-
-  python $UTILS/tmx2corpus/tmx2corpus.py $TMX_FILE
-}
-
-prepare_pl() {
-  OUTPUT_DIR=$TMP_DIR/pl
-  mkdir -p $OUTPUT_DIR
-  cd $OUTPUT_DIR
-
-  # download_and_select europarl "http://www.statmt.org/europarl/v10/training/europarl-v10.pl-en.tsv.gz" "gunzip europarl-v10.pl-en.tsv.gz" pl europarl-v10.pl-en.tsv 1 2 &
-  # download_and_select paracrawl "https://s3.amazonaws.com/web-language-models/paracrawl/release5.1/en-pl.txt.gz" "gunzip en-pl.txt.gz" pl en-pl.txt 2 1 &
-  # download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.pl-en.tsv.gz" "gunzip wikititles-v2.pl-en.tsv.gz" pl wikititles-v2.pl-en.tsv 1 2 &
-  download_and_select tilde "https://tilde-model.s3-eu-west-1.amazonaws.com/rapid2019.en-pl.tmx.zip" "gunzip rapid2019.en-pl.tmx.zip" bitext pl "prepare_tmx RAPID_2019.UNIQUE.en-pl.tmx" &
-  # download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.en-pl.langid.tsv.gz" "gunzip WikiMatrix.v1.en-pl.langid.tsv.gz" pl WikiMatrix.v1.en-pl.langid.tsv 3 2 &
-
-  wait
-
-  # remove previous results
-  rm -f all.??
-  find ./ -maxdepth 1 -name "*.pl" | sort -V | xargs cat > all.pl
-  find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en
-  lid_filter pl all.pl $DEST/train.pl_PL-en_XX.pl_PL en all.en $DEST/train.pl_PL-en_XX.en_XX
-}
-
-prepare_uncorpus() {
-  $URLS=$1
-  $FILES=$2
-
-  mkdir -p uncorpus
-  cd uncorpus
-
-  for URL in $URLS; do
-    wget -nc $URL
-  done
-  cat $FILES > uncorpus.tar.gz
-  tar -zxvf uncorpus.tar.gz
-
-  cd ..
-  ln -sf uncorpus/en-$LANG/UNv1.0.en-$LANG.$LANG uncorpus.$LANG
-  ln -sf uncorpus/en-$LANG/UNv1.0.en-$LANG.en uncorpus.en
-}
-
-prepare_yandex() {
-  mkdir -p yandex
-  cd yandex
-  unzip $YANDEX_CORPUS ./
-  cd ..
-  ln -s yandex/corpus.en_ru.1m.en yandex.en
-  ln -s yandex/corpus.en_ru.1m.ru yandex.ru
-}
-
-prepare_ru() {
-  OUTPUT_DIR=$TMP_DIR/ru
-  mkdir -p $OUTPUT_DIR
-  cd $OUTPUT_DIR
-
-  download_and_select paracrawl "https://s3.amazonaws.com/web-language-models/paracrawl/release1/paracrawl-release1.en-ru.zipporah0-dedup-clean.tgz" "tar -zxvf paracrawl-release1.en-ru.zipporah0-dedup-clean.tgz" ru paracrawl-release1.en-ru.zipporah0-dedup-clean &
-  link_commoncrawl ru
-  download_and_select newscommentary "http://data.statmt.org/news-commentary/v15/training/news-commentary-v15.en-ru.tsv.gz" "gunzip news-commentary-v15.en-ru.tsv.gz" ru news-commentary-v15.en-ru.tsv 2 1 &
-  prepare_yandex &
-  download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.ru-en.tsv.gz" "gunzip wikititles-v2.ru-en.tsv.gz" ru wikititles-v2.ru-en.tsv 1 2 &
-  prepare_uncorpus "https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-ru.tar.gz.00 https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-ru.tar.gz.01 https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-ru.tar.gz.02" "UNv1.0.en-ru.tar.gz.00 UNv1.0.en-ru.tar.gz.01 UNv1.0.en-ru.tar.gz.02" &
-  download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.en-ru.langid.tsv.gz" "gunzip WikiMatrix.v1.en-ru.langid.tsv.gz" ru WikiMatrix.v1.en-ru.langid.tsv 3 2 &
-
-  wait
-
-  # remove previous results
-  rm -f all.??
-  find ./ -maxdepth 1 -name "*.ru" | sort -V | xargs cat > all.ru
-  find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en
-  lid_filter ru all.ru $DEST/train.ru_RU-en_XX.ru_RU en all.en $DEST/train.ru_RU-en_XX.en_XX
-}
-
-prepare_ccmt() {
-  mkdir -p ccmt
-  cd ccmt
-  # assume ccmt data is already unzipped under CCMT_DIR folder
-  cat $CCMT_DIR/datum2017/Book*_cn.txt | sed 's/ //g' > datum2017.detok.zh
-  cat $CCMT_DIR/datum2017/Book*_en.txt > datum2017.detok.en
-  cat $CCMT_DIR/casict2011/casict-A_ch.txt $CCMT_DIR/casict2011/casict-B_ch.txt $CCMT_DIR/casict2015/casict2015_ch.txt $CCMT_DIR/datum2015/datum_ch.txt $CCMT_DIR/neu2017/NEU_cn.txt datum2017.detok.zh > ccmt.zh
-  cat $CCMT_DIR/casict2011/casict-A_en.txt $CCMT_DIR/casict2011/casict-B_en.txt $CCMT_DIR/casict2015/casict2015_en.txt $CCMT_DIR/datum2015/datum_en.txt $CCMT_DIR/neu2017/NEU_en.txt datum2017.detok.en > ccmt.en
-  cd ..
-  ln -sf ccmt/ccmt.zh ccmt.zh
-  ln -sf ccmt/ccmt.en ccmt.en
-}
-
-prepare_zh() {
-  OUTPUT_DIR=$TMP_DIR/zh
-  mkdir -p $OUTPUT_DIR
-  cd $OUTPUT_DIR
-
-  download_and_select newscommentary "http://data.statmt.org/news-commentary/v15/training/news-commentary-v15.en-zh.tsv.gz" "gunzip news-commentary-v15.en-zh.tsv.gz" zh news-commentary-v15.en-zh.tsv 2 1 &
-  download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.zh-en.tsv.gz" "gunzip wikititles-v2.zh-en.tsv.gz" zh wikititles-v2.zh-en.tsv 1 2 &
-  prepare_uncorpus "https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-zh.tar.gz.00 https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-zh.tar.gz.01" "UNv1.0.en-zh.tar.gz.00 UNv1.0.en-zh.tar.gz.01" &
-  prepare_ccmt &
-  download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.en-zh.langid.tsv.gz" "gunzip WikiMatrix.v1.en-zh.langid.tsv.gz" zh WikiMatrix.v1.en-zh.langid.tsv 3 2 &
-
-  wait
-
-  # remove previous results
-  rm -f all.??
-  find ./ -maxdepth 1 -name "*.zh" | sort -V | xargs cat > all.zh
-  find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en
-  lid_filter zh all.zh $DEST/train.zh_CN-en_XX.zh_CN en all.en $DEST/train.zh_CN-en_XX.en_XX
-}
-
-prepare_tests() {
-  OUTPUT_DIR=$TMP_DIR
-  mkdir -p $OUTPUT_DIR
-  cd $OUTPUT_DIR
-  wget -nc http://data.statmt.org/wmt20/translation-task/dev.tgz
-  tar -zxvf dev.tgz
-  cd dev
-
-  cat newsdev2020-jaen-src.ja.sgm | $UTILS/strip_sgm.sh > newsdev2020-jaen.ja
-  cat newsdev2020-jaen-ref.en.sgm | $UTILS/strip_sgm.sh > newsdev2020-jaen.en
-  split newsdev2020-jaen.ja -a 0 -n r/1/2 > $DEST/valid.ja_XX-en_XX.ja_XX
-  split newsdev2020-jaen.en -a 0 -n r/1/2 > $DEST/valid.ja_XX-en_XX.en_XX
-  split newsdev2020-jaen.ja -a 0 -n r/2/2 > $DEST/test.ja_XX-en_XX.ja_XX
-  split newsdev2020-jaen.en -a 0 -n r/2/2 > $DEST/test.ja_XX-en_XX.en_XX
-
-  cat newsdev2020-iuen-src.iu.sgm | strip_sgm.sh > newsdev2020-iuen.iu
-  cat newsdev2020-iuen-ref.en.sgm | strip_sgm.sh > newsdev2020-iuen.en
-  split newsdev2020-iuen.iu -a 0 -n r/1/2 > $DEST/valid.iu_CA-en_XX.iu_CA
-  split newsdev2020-iuen.en -a 0 -n r/1/2 > $DEST/valid.iu_CA-en_XX.en_XX
-  split newsdev2020-iuen.iu -a 0 -n r/2/2 > $DEST/test.iu_CA-en_XX.iu_CA
-  split newsdev2020-iuen.en -a 0 -n r/2/2 > $DEST/test.iu_CA-en_XX.en_XX
-
-  cat newsdev2020-taen-src.ta.sgm | strip_sgm.sh > newsdev2020-taen.ta
-  cat newsdev2020-taen-ref.en.sgm | strip_sgm.sh > newsdev2020-taen.en
-  split newsdev2020-taen.ta -a 0 -n r/1/2 > $DEST/valid.ta_IN-en_XX.ta_IN
-  split newsdev2020-taen.en -a 0 -n r/1/2 > $DEST/valid.ta_IN-en_XX.en_XX
-  split newsdev2020-taen.ta -a 0 -n r/2/2 > $DEST/test.ta_IN-en_XX.ta_IN
-  split newsdev2020-taen.en -a 0 -n r/2/2 > $DEST/test.ta_IN-en_XX.en_XX
-
-  cp wikipedia.dev.km-en.km $DEST/valid.km_KH-en_XX.km_KH
-  cp wikipedia.dev.km-en.en $DEST/valid.km_KH-en_XX.en_XX
-  cp wikipedia.devtest.km-en.km $DEST/test.km_KH-en_XX.km_KH
-  cp wikipedia.devtest.km-en.en $DEST/test.km_KH-en_XX.en_XX
-
-  cp wikipedia.dev.ps-en.ps $DEST/valid.ps_AF-en_XX.ps_AF
-  cp wikipedia.dev.ps-en.en $DEST/valid.ps_AF-en_XX.en_XX
-  cp wikipedia.devtest.ps-en.ps $DEST/test.ps_AF-en_XX.ps_AF
-  cp wikipedia.devtest.ps-en.en $DEST/test.ps_AF-en_XX.en_XX
-
-  cat newsdev2020-plen-src.pl.sgm | strip_sgm.sh > newsdev2020-plen.pl
-  cat newsdev2020-plen-ref.en.sgm | strip_sgm.sh > newsdev2020-plen.en
-  split newsdev2020-plen.pl -a 0 -n r/1/2 > $DEST/valid.pl_PL-en_XX.pl_PL
-  split newsdev2020-plen.en -a 0 -n r/1/2 > $DEST/valid.pl_PL-en_XX.en_XX
-  split newsdev2020-plen.pl -a 0 -n r/2/2 > $DEST/test.pl_PL-en_XX.pl_PL
-  split newsdev2020-plen.en -a 0 -n r/2/2 > $DEST/test.pl_PL-en_XX.en_XX
-
-  cat newstest2018-encs-src.en.sgm | strip_sgm.sh > $DEST/valid.en_XX-cs_CZ.en_XX
-  cat newstest2018-encs-ref.cs.sgm | strip_sgm.sh > $DEST/valid.en_XX-cs_CZ.cs_CZ
-  cat newstest2019-encs-src.en.sgm | strip_sgm.sh > $DEST/test.en_XX-cs_CZ.en_XX
-  cat newstest2019-encs-ref.cs.sgm | strip_sgm.sh > $DEST/test.en_XX-cs_CZ.cs_CZ
-
-  cat newstest2018-deen-src.de.sgm | strip_sgm.sh > $DEST/valid.de_DE-en_XX.de_DE
-  cat newstest2018-deen-ref.en.sgm | strip_sgm.sh > $DEST/valid.de_DE-en_XX.en_XX
-  cat newstest2018-ende-src.en.sgm | strip_sgm.sh > $DEST/valid.en_XX-de_DE.en_XX
-  cat newstest2018-ende-ref.de.sgm | strip_sgm.sh > $DEST/valid.en_XX-de_DE.de_DE
-  cat newstest2019-deen-src.de.sgm | strip_sgm.sh > $DEST/test.de_DE-en_XX.de_DE
-  cat newstest2019-deen-ref.en.sgm | strip_sgm.sh > $DEST/test.de_DE-en_XX.en_XX
-  cat newstest2019-ende-src.en.sgm | strip_sgm.sh > $DEST/test.en_XX-de_DE.en_XX
-  cat newstest2019-ende-ref.de.sgm | strip_sgm.sh > $DEST/test.en_XX-de_DE.de_DE
-
-  cat newstest2018-ruen-src.ru.sgm | strip_sgm.sh > $DEST/valid.ru_RU-en_XX.ru_RU
-  cat newstest2018-ruen-ref.en.sgm | strip_sgm.sh > $DEST/valid.ru_RU-en_XX.en_XX
-  cat newstest2018-enru-src.en.sgm | strip_sgm.sh > $DEST/valid.en_XX-ru_RU.en_XX
-  cat newstest2018-enru-ref.ru.sgm | strip_sgm.sh > $DEST/valid.en_XX-ru_RU.ru_RU
-  cat newstest2019-ruen-src.ru.sgm | strip_sgm.sh > $DEST/test.ru_RU-en_XX.ru_RU
-  cat newstest2019-ruen-ref.en.sgm | strip_sgm.sh > $DEST/test.ru_RU-en_XX.en_XX
-  cat newstest2019-enru-src.en.sgm | strip_sgm.sh > $DEST/test.en_XX-ru_RU.en_XX
-  cat newstest2019-enru-ref.ru.sgm | strip_sgm.sh > $DEST/test.en_XX-ru_RU.ru_RU
-
-  cat newstest2018-zhen-src.zh.sgm | strip_sgm.sh > $DEST/valid.zh_CN-en_XX.zh_CN
-  cat newstest2018-zhen-ref.en.sgm | strip_sgm.sh > $DEST/valid.zh_CN-en_XX.en_XX
-  cat newstest2018-enzh-src.en.sgm | strip_sgm.sh > $DEST/valid.en_XX-zh_CN.en_XX
-  cat newstest2018-enzh-ref.zh.sgm | strip_sgm.sh > $DEST/valid.en_XX-zh_CN.zh_CN
-  cat newstest2019-zhen-src.zh.sgm | strip_sgm.sh > $DEST/test.zh_CN-en_XX.zh_CN
-  cat newstest2019-zhen-ref.en.sgm | strip_sgm.sh > $DEST/test.zh_CN-en_XX.en_XX
-  cat newstest2019-enzh-src.en.sgm | strip_sgm.sh > $DEST/test.en_XX-zh_CN.en_XX
-  cat newstest2019-enzh-ref.zh.sgm | strip_sgm.sh > $DEST/test.en_XX-zh_CN.zh_CN
-}
-
-mkdir -p $DEST
-
-prepare_lid
-prepare_moses
-download_commoncrawl
-
-prepare_ja &
-prepare_ta &
-prepare_km &
-prepare_ps &
-prepare_iu &
-prepare_cs &
-prepare_de &
-prepare_pl &
-prepare_ru &
-prepare_zh &
-
-# prepare valid/test set
-prepare_tests &
-
-# wait
-
-# TODO remove intermediate files
-# rm -rf $TMP_DIR
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/models/huggingface/hf_gpt2.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/models/huggingface/hf_gpt2.py
deleted file mode 100644
index 3a8eb78198f5808557092f814e92f1c9d72933ec..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/models/huggingface/hf_gpt2.py
+++ /dev/null
@@ -1,168 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-import os
-import sys
-from typing import Dict, List, Optional
-
-import torch
-from fairseq.models import (
-    FairseqIncrementalDecoder,
-    FairseqLanguageModel,
-    register_model,
-    register_model_architecture,
-)
-
-
-logger = logging.getLogger(__name__)
-
-
-DEFAULT_MAX_TARGET_POSITIONS = 1024
-
-
-@register_model("hf_gpt2")
-class HuggingFaceGPT2LanguageModel(FairseqLanguageModel):
-    def __init__(self, decoder):
-        super().__init__(decoder)
-
-    @staticmethod
-    def add_args(parser):
-        """Add model-specific arguments to the parser."""
-        # fmt: off
-        parser.add_argument('--embed-dim', type=int, metavar='N',
-                            help='embedding dimension')
-        parser.add_argument('--num-attention-heads', type=int, metavar='N',
-                            help='num attention heads')
-        parser.add_argument('--num-layers', type=int, metavar='N',
-                            help='num layers')
-        parser.add_argument('--dropout', type=float, metavar='D',
-                            help='dropout probability for all fully connected layers '
-                                 'in the embeddings, encoder, and pooler')
-        parser.add_argument('--attention-dropout', type=float, metavar='D',
-                            help='dropout probability for attention weights')
-        # fmt: on
-
-    @classmethod
-    def build_model(cls, args, task):
-        """Build a new model instance."""
-        default_architecture(args)
-        return cls(HuggingFaceGPT2Decoder(args, task))
-
-
-class HuggingFaceGPT2Decoder(FairseqIncrementalDecoder):
-    def __init__(self, args, task):
-        try:
-            from transformers import GPT2Config, GPT2LMHeadModel
-        except ImportError:
-            raise ImportError(
-                "\n\nPlease install huggingface/transformers with:"
-                "\n\n  pip install transformers"
-            )
-
-        super().__init__(task.target_dictionary)
-
-        config = GPT2Config(
-            vocab_size=len(task.target_dictionary),
-            n_positions=args.max_target_positions + 1,
-            n_ctx=args.max_target_positions,
-            n_embd=args.embed_dim,
-            n_layer=args.num_layers,
-            n_head=args.num_attention_heads,
-            resid_pdrop=args.dropout,
-            embd_pdrop=args.dropout,
-            attn_pdrop=args.attention_dropout,
-            layer_norm_epsilon=1e-6,
-        )
-        self.model = GPT2LMHeadModel(config)
-
-        # set zero embedding for padding symbol
-        self.pad_idx = task.target_dictionary.pad()
-        self.model.transformer.wte.weight.data[self.pad_idx].zero_()
-        self.model.transformer.wpe.weight.data[0].zero_()
-
-    def forward(
-        self,
-        prev_output_tokens,
-        src_lengths=None,
-        incremental_state: Optional[Dict[str, List[torch.Tensor]]] = None,
-        encoder_out=None,
-    ):
-        features = self.extract_features(prev_output_tokens, incremental_state)
-        lm_logits = self.model.lm_head(features)
-        return (lm_logits,)
-
-    def extract_features(
-        self,
-        prev_output_tokens,
-        incremental_state: Optional[Dict[str, List[torch.Tensor]]] = None,
-    ):
-        if incremental_state:
-            past = self.get_incremental_state("past")
-        else:
-            past = None
-
-        # don't attend to padding symbols
-        attention_mask = prev_output_tokens.ne(self.pad_idx).int()
-
-        # set position ids to exclude padding symbols
-        position_ids = attention_mask * (
-            torch.arange(1, 1 + prev_output_tokens.size(1))
-            .to(prev_output_tokens)
-            .repeat(prev_output_tokens.size(0), 1)
-        )
-
-        outputs = self.model.transformer(
-            input_ids=prev_output_tokens,
-            past=past,
-            attention_mask=attention_mask,
-            position_ids=position_ids,
-        )
-        last_hidden_states = outputs[0]
-
-        if incremental_state:
-            self.set_incremental_state(incremental_state, "past", outputs[1])
-
-        return last_hidden_states
-
-    def max_positions(self):
-        return self.model.config.n_positions - 1
-
-
-@register_model_architecture("hf_gpt2", "hf_gpt2")
-def default_architecture(args):
-    if getattr(args, "max_target_positions", None) is None:
-        args.max_target_positions = getattr(
-            args, "tokens_per_sample", DEFAULT_MAX_TARGET_POSITIONS
-        )
-    args.embed_dim = getattr(args, "embed_dim", 768)
-    args.num_attention_heads = getattr(args, "num_attention_heads", 12)
-    args.num_layers = getattr(args, "num_layers", 12)
-    args.dropout = getattr(args, "dropout", 0.1)
-    args.attention_dropout = getattr(args, "attention_dropout", 0.1)
-
-
-@register_model_architecture("hf_gpt2", "hf_gpt2_medium")
-def hf_gpt2_medium(args):
-    args.embed_dim = getattr(args, "embed_dim", 1024)
-    args.num_attention_heads = getattr(args, "num_attention_heads", 16)
-    args.num_layers = getattr(args, "num_layers", 24)
-    default_architecture(args)
-
-
-@register_model_architecture("hf_gpt2", "hf_gpt2_large")
-def hf_gpt2_large(args):
-    args.embed_dim = getattr(args, "embed_dim", 1280)
-    args.num_attention_heads = getattr(args, "num_attention_heads", 20)
-    args.num_layers = getattr(args, "num_layers", 36)
-    default_architecture(args)
-
-
-@register_model_architecture("hf_gpt2", "hf_gpt2_xl")
-def hf_gpt2_xl(args):
-    args.embed_dim = getattr(args, "embed_dim", 1600)
-    args.num_attention_heads = getattr(args, "num_attention_heads", 25)
-    args.num_layers = getattr(args, "num_layers", 48)
-    default_architecture(args)
diff --git a/spaces/ICML2022/OFA/fairseq/examples/simultaneous_translation/modules/fixed_pre_decision.py b/spaces/ICML2022/OFA/fairseq/examples/simultaneous_translation/modules/fixed_pre_decision.py
deleted file mode 100644
index 3991414aed3800f301e4097e819d3064bb549c37..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/examples/simultaneous_translation/modules/fixed_pre_decision.py
+++ /dev/null
@@ -1,190 +0,0 @@
-from functools import partial
-
-import torch
-from torch import Tensor
-import math
-import torch.nn.functional as F
-
-from . import register_monotonic_attention
-from .monotonic_multihead_attention import (
-    MonotonicAttention,
-    MonotonicInfiniteLookbackAttention,
-    WaitKAttention
-)
-from typing import Dict, Optional
-
-
-def fixed_pooling_monotonic_attention(monotonic_attention):
-    def create_model(monotonic_attention, klass):
-        class FixedStrideMonotonicAttention(monotonic_attention):
-            def __init__(self, args):
-                self.waitk_lagging = 0
-                self.num_heads = 0
-                self.noise_mean = 0.0
-                self.noise_var = 0.0
-                super().__init__(args)
-                self.pre_decision_type = args.fixed_pre_decision_type
-                self.pre_decision_ratio = args.fixed_pre_decision_ratio
-                self.pre_decision_pad_threshold = args.fixed_pre_decision_pad_threshold
-                assert self.pre_decision_ratio > 1
-
-                if args.fixed_pre_decision_type == "average":
-                    self.pooling_layer = torch.nn.AvgPool1d(
-                        kernel_size=self.pre_decision_ratio,
-                        stride=self.pre_decision_ratio,
-                        ceil_mode=True,
-                    )
-                elif args.fixed_pre_decision_type == "last":
-
-                    def last(key):
-                        if key.size(2) < self.pre_decision_ratio:
-                            return key
-                        else:
-                            k = key[
-                                :,
-                                :,
-                                self.pre_decision_ratio - 1:: self.pre_decision_ratio,
-                            ].contiguous()
-                            if key.size(-1) % self.pre_decision_ratio != 0:
-                                k = torch.cat([k, key[:, :, -1:]], dim=-1).contiguous()
-                            return k
-
-                    self.pooling_layer = last
-                else:
-                    raise NotImplementedError
-
-            @staticmethod
-            def add_args(parser):
-                super(
-                    FixedStrideMonotonicAttention, FixedStrideMonotonicAttention
-                ).add_args(parser)
-                parser.add_argument(
-                    "--fixed-pre-decision-ratio",
-                    type=int,
-                    required=True,
-                    help=(
-                        "Ratio for the fixed pre-decision,"
-                        "indicating how many encoder steps will start"
-                        "simultaneous decision making process."
-                    ),
-                )
-                parser.add_argument(
-                    "--fixed-pre-decision-type",
-                    default="average",
-                    choices=["average", "last"],
-                    help="Pooling type",
-                )
-                parser.add_argument(
-                    "--fixed-pre-decision-pad-threshold",
-                    type=float,
-                    default=0.3,
-                    help="If a part of the sequence has pad"
-                    ",the threshold the pooled part is a pad.",
-                )
-
-            def insert_zeros(self, x):
-                bsz_num_heads, tgt_len, src_len = x.size()
-                stride = self.pre_decision_ratio
-                weight = F.pad(torch.ones(1, 1, 1).to(x), (stride - 1, 0))
-                x_upsample = F.conv_transpose1d(
-                    x.view(-1, src_len).unsqueeze(1),
-                    weight,
-                    stride=stride,
-                    padding=0,
-                )
-                return x_upsample.squeeze(1).view(bsz_num_heads, tgt_len, -1)
-
-            def p_choose(
-                self,
-                query: Optional[Tensor],
-                key: Optional[Tensor],
-                key_padding_mask: Optional[Tensor] = None,
-                incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
-            ):
-                assert key is not None
-                assert query is not None
-                src_len = key.size(0)
-                tgt_len = query.size(0)
-                batch_size = query.size(1)
-
-                key_pool = self.pooling_layer(key.transpose(0, 2)).transpose(0, 2)
-
-                if key_padding_mask is not None:
-                    key_padding_mask_pool = (
-                        self.pooling_layer(key_padding_mask.unsqueeze(0).float())
-                        .squeeze(0)
-                        .gt(self.pre_decision_pad_threshold)
-                    )
-                    # Make sure at least one element is not pad
-                    key_padding_mask_pool[:, 0] = 0
-                else:
-                    key_padding_mask_pool = None
-
-                if incremental_state is not None:
-                    # The floor instead of ceil is used for inference
-                    # But make sure the length key_pool at least 1
-                    if (
-                        max(1, math.floor(key.size(0) / self.pre_decision_ratio))
-                    ) < key_pool.size(0):
-                        key_pool = key_pool[:-1]
-                        if key_padding_mask_pool is not None:
-                            key_padding_mask_pool = key_padding_mask_pool[:-1]
-
-                p_choose_pooled = self.p_choose_from_qk(
-                    query,
-                    key_pool,
-                    key_padding_mask_pool,
-                    incremental_state=incremental_state,
-                )
-
-                # Upsample, interpolate zeros
-                p_choose = self.insert_zeros(p_choose_pooled)
-
-                if p_choose.size(-1) < src_len:
-                    # Append zeros if the upsampled p_choose is shorter than src_len
-                    p_choose = torch.cat(
-                        [
-                            p_choose,
-                            torch.zeros(
-                                p_choose.size(0),
-                                tgt_len,
-                                src_len - p_choose.size(-1)
-                            ).to(p_choose)
-                        ],
-                        dim=2
-                    )
-                else:
-                    # can be larger than src_len because we used ceil before
-                    p_choose = p_choose[:, :, :src_len]
-                    p_choose[:, :, -1] = p_choose_pooled[:, :, -1]
-
-                assert list(p_choose.size()) == [
-                    batch_size * self.num_heads,
-                    tgt_len,
-                    src_len,
-                ]
-
-                return p_choose
-
-        FixedStrideMonotonicAttention.__name__ = klass.__name__
-        return FixedStrideMonotonicAttention
-
-    return partial(create_model, monotonic_attention)
-
-
-@register_monotonic_attention("waitk_fixed_pre_decision")
-@fixed_pooling_monotonic_attention(WaitKAttention)
-class WaitKAttentionFixedStride:
-    pass
-
-
-@register_monotonic_attention("hard_aligned_fixed_pre_decision")
-@fixed_pooling_monotonic_attention(MonotonicAttention)
-class MonotonicAttentionFixedStride:
-    pass
-
-
-@register_monotonic_attention("infinite_lookback_fixed_pre_decision")
-@fixed_pooling_monotonic_attention(MonotonicInfiniteLookbackAttention)
-class MonotonicInfiniteLookbackAttentionFixedStride:
-    pass
diff --git a/spaces/Illumotion/Koboldcpp/koboldcpp.py b/spaces/Illumotion/Koboldcpp/koboldcpp.py
deleted file mode 100644
index 0b0b9f31f2b5fe8018a600f177447f77c5fd664a..0000000000000000000000000000000000000000
--- a/spaces/Illumotion/Koboldcpp/koboldcpp.py
+++ /dev/null
@@ -1,1883 +0,0 @@
-#!/usr/bin/env python3
-#-*- coding: utf-8 -*-
-
-# KoboldCpp is an easy-to-use AI text-generation software for GGML models.
-# It's a single self contained distributable from Concedo, that builds off llama.cpp,
-# and adds a versatile Kobold API endpoint, additional format support,
-# backward compatibility, as well as a fancy UI with persistent stories,
-# editing tools, save formats, memory, world info, author's note, characters,
-# scenarios and everything Kobold and Kobold Lite have to offer.
-
-import ctypes
-import os
-import argparse
-import json, sys, http.server, time, asyncio, socket, threading
-from concurrent.futures import ThreadPoolExecutor
-
-sampler_order_max = 7
-stop_token_max = 16
-ban_token_max = 16
-tensor_split_max = 16
-
-class load_model_inputs(ctypes.Structure):
-    _fields_ = [("threads", ctypes.c_int),
-                ("blasthreads", ctypes.c_int),
-                ("max_context_length", ctypes.c_int),
-                ("batch_size", ctypes.c_int),
-                ("f16_kv", ctypes.c_bool),
-                ("low_vram", ctypes.c_bool),
-                ("use_mmq", ctypes.c_bool),
-                ("executable_path", ctypes.c_char_p),
-                ("model_filename", ctypes.c_char_p),
-                ("lora_filename", ctypes.c_char_p),
-                ("lora_base", ctypes.c_char_p),
-                ("use_mmap", ctypes.c_bool),
-                ("use_mlock", ctypes.c_bool),
-                ("use_smartcontext", ctypes.c_bool),
-                ("clblast_info", ctypes.c_int),
-                ("cublas_info", ctypes.c_int),
-                ("blasbatchsize", ctypes.c_int),
-                ("debugmode", ctypes.c_int),
-                ("forceversion", ctypes.c_int),
-                ("gpulayers", ctypes.c_int),
-                ("rope_freq_scale", ctypes.c_float),
-                ("rope_freq_base", ctypes.c_float),
-                ("banned_tokens", ctypes.c_char_p * ban_token_max),
-                ("tensor_split", ctypes.c_float * tensor_split_max)]
-
-class generation_inputs(ctypes.Structure):
-    _fields_ = [("seed", ctypes.c_int),
-                ("prompt", ctypes.c_char_p),
-                ("max_context_length", ctypes.c_int),
-                ("max_length", ctypes.c_int),
-                ("temperature", ctypes.c_float),
-                ("top_k", ctypes.c_int),
-                ("top_a", ctypes.c_float),
-                ("top_p", ctypes.c_float),
-                ("typical_p", ctypes.c_float),
-                ("tfs", ctypes.c_float),
-                ("rep_pen", ctypes.c_float),
-                ("rep_pen_range", ctypes.c_int),
-                ("mirostat", ctypes.c_int),
-                ("mirostat_tau", ctypes.c_float),
-                ("mirostat_eta", ctypes.c_float),
-                ("sampler_order", ctypes.c_int * sampler_order_max),
-                ("sampler_len", ctypes.c_int),
-                ("unban_tokens_rt", ctypes.c_bool),
-                ("stop_sequence", ctypes.c_char_p * stop_token_max),
-                ("stream_sse", ctypes.c_bool),
-                ("grammar", ctypes.c_char_p),
-                ("grammar_retain_state", ctypes.c_bool)]
-
-class generation_outputs(ctypes.Structure):
-    _fields_ = [("status", ctypes.c_int),
-                ("text", ctypes.c_char * 24576)]
-
-handle = None
-
-def getdirpath():
-    return os.path.dirname(os.path.realpath(__file__))
-def getabspath():
-    return os.path.dirname(os.path.abspath(__file__))
-def file_exists(filename):
-    return os.path.exists(os.path.join(getdirpath(), filename))
-
-def pick_existant_file(ntoption,nonntoption):
-    precompiled_prefix = "precompiled_"
-    ntexist = file_exists(ntoption)
-    nonntexist = file_exists(nonntoption)
-    precompiled_ntexist = file_exists(precompiled_prefix+ntoption)
-    precompiled_nonntexist = file_exists(precompiled_prefix+nonntoption)
-    if os.name == 'nt':
-        if not ntexist and precompiled_ntexist:
-            return (precompiled_prefix+ntoption)
-        if nonntexist and not ntexist:
-            return nonntoption
-        return ntoption
-    else:
-        if not nonntexist and precompiled_nonntexist:
-            return (precompiled_prefix+nonntoption)
-        if ntexist and not nonntexist:
-            return ntoption
-        return nonntoption
-
-lib_default = pick_existant_file("koboldcpp_default.dll","koboldcpp_default.so")
-lib_failsafe = pick_existant_file("koboldcpp_failsafe.dll","koboldcpp_failsafe.so")
-lib_openblas = pick_existant_file("koboldcpp_openblas.dll","koboldcpp_openblas.so")
-lib_noavx2 = pick_existant_file("koboldcpp_noavx2.dll","koboldcpp_noavx2.so")
-lib_clblast = pick_existant_file("koboldcpp_clblast.dll","koboldcpp_clblast.so")
-lib_cublas = pick_existant_file("koboldcpp_cublas.dll","koboldcpp_cublas.so")
-lib_hipblas = pick_existant_file("koboldcpp_hipblas.dll","koboldcpp_hipblas.so")
-
-
-def init_library():
-    global handle, args
-    global lib_default,lib_failsafe,lib_openblas,lib_noavx2,lib_clblast,lib_cublas
-
-    libname = ""
-    use_openblas = False # if true, uses OpenBLAS for acceleration. libopenblas.dll must exist in the same dir.
-    use_clblast = False #uses CLBlast instead
-    use_cublas = False #uses cublas instead
-    use_hipblas = False #uses hipblas instead
-    use_noavx2 = False #uses no avx2 instructions
-    use_failsafe = False #uses no intrinsics, failsafe mode
-    if args.noavx2:
-        use_noavx2 = True
-        if not file_exists(lib_noavx2):
-            print("Warning: NoAVX2 library file not found. Failsafe library will be used.")
-        elif (args.noblas and args.nommap):
-            use_failsafe = True
-            print("!!! Attempting to use FAILSAFE MODE !!!")
-        else:
-            print("Attempting to use non-avx2 compatibility library.")
-    elif args.useclblast:
-        if not file_exists(lib_clblast) or (os.name=='nt' and not file_exists("clblast.dll")):
-            print("Warning: CLBlast library file not found. Non-BLAS library will be used.")
-        else:
-            print("Attempting to use CLBlast library for faster prompt ingestion. A compatible clblast will be required.")
-            use_clblast = True
-    elif (args.usecublas is not None):
-        if not file_exists(lib_cublas) and not file_exists(lib_hipblas):
-            print("Warning: CuBLAS library file not found. Non-BLAS library will be used.")
-        else:
-            if file_exists(lib_cublas):
-                print("Attempting to use CuBLAS library for faster prompt ingestion. A compatible CuBLAS will be required.")
-                use_cublas = True
-            elif file_exists(lib_hipblas):
-                print("Attempting to use hipBLAS library for faster prompt ingestion. A compatible AMD GPU will be required.")
-                use_hipblas = True
-
-    else:
-        if not file_exists(lib_openblas) or (os.name=='nt' and not file_exists("libopenblas.dll")):
-            print("Warning: OpenBLAS library file not found. Non-BLAS library will be used.")
-        elif args.noblas:
-            print("Attempting to library without OpenBLAS.")
-        else:
-            use_openblas = True
-            print("Attempting to use OpenBLAS library for faster prompt ingestion. A compatible libopenblas will be required.")
-            if sys.platform=="darwin":
-                print("Mac OSX note: Some people have found Accelerate actually faster than OpenBLAS. To compare, run Koboldcpp with --noblas instead.")
-
-    if use_noavx2:
-        if use_failsafe:
-            libname = lib_failsafe
-        else:
-            libname = lib_noavx2
-    else:
-        if use_clblast:
-            libname = lib_clblast
-        elif use_cublas:
-            libname = lib_cublas
-        elif use_hipblas:
-            libname = lib_hipblas
-        elif use_openblas:
-            libname = lib_openblas
-        else:
-            libname = lib_default
-
-    print("Initializing dynamic library: " + libname)
-    dir_path = getdirpath()
-    abs_path = getabspath()
-
-    #add all potential paths
-    if os.name=='nt':
-        os.add_dll_directory(dir_path)
-        os.add_dll_directory(abs_path)
-        os.add_dll_directory(os.getcwd())
-    handle = ctypes.CDLL(os.path.join(dir_path, libname))
-
-    handle.load_model.argtypes = [load_model_inputs]
-    handle.load_model.restype = ctypes.c_bool
-    handle.generate.argtypes = [generation_inputs, ctypes.c_wchar_p] #apparently needed for osx to work. i duno why they need to interpret it that way but whatever
-    handle.generate.restype = generation_outputs
-    handle.new_token.restype = ctypes.c_char_p
-    handle.new_token.argtypes = [ctypes.c_int]
-    handle.get_stream_count.restype = ctypes.c_int
-    handle.has_finished.restype = ctypes.c_bool
-    handle.get_last_eval_time.restype = ctypes.c_float
-    handle.get_last_process_time.restype = ctypes.c_float
-    handle.get_last_token_count.restype = ctypes.c_int
-    handle.get_last_stop_reason.restype = ctypes.c_int
-    handle.abort_generate.restype = ctypes.c_bool
-    handle.token_count.restype = ctypes.c_int
-    handle.get_pending_output.restype = ctypes.c_char_p
-
-def load_model(model_filename):
-    global args
-    inputs = load_model_inputs()
-    inputs.model_filename = model_filename.encode("UTF-8")
-    inputs.batch_size = 8
-    inputs.max_context_length = maxctx #initial value to use for ctx, can be overwritten
-    inputs.threads = args.threads
-    inputs.low_vram = (True if (args.usecublas and "lowvram" in args.usecublas) else False)
-    inputs.use_mmq = (True if (args.usecublas and "mmq" in args.usecublas) else False)
-    inputs.blasthreads = args.blasthreads
-    inputs.f16_kv = True
-    inputs.use_mmap = (not args.nommap)
-    inputs.use_mlock = args.usemlock
-    inputs.lora_filename = "".encode("UTF-8")
-    inputs.lora_base = "".encode("UTF-8")
-    if args.lora:
-        inputs.lora_filename = args.lora[0].encode("UTF-8")
-        inputs.use_mmap = False
-        if len(args.lora) > 1:
-            inputs.lora_base = args.lora[1].encode("UTF-8")
-    inputs.use_smartcontext = args.smartcontext
-    inputs.blasbatchsize = args.blasbatchsize
-    inputs.forceversion = args.forceversion
-    inputs.gpulayers = args.gpulayers
-    inputs.rope_freq_scale = args.ropeconfig[0]
-    if len(args.ropeconfig)>1:
-        inputs.rope_freq_base = args.ropeconfig[1]
-    else:
-        inputs.rope_freq_base = 10000
-    clblastids = 0
-    if args.useclblast:
-        clblastids = 100 + int(args.useclblast[0])*10 + int(args.useclblast[1])
-    inputs.clblast_info = clblastids
-
-    for n in range(tensor_split_max):
-        if args.tensor_split and n < len(args.tensor_split):
-            inputs.tensor_split[n] = float(args.tensor_split[n])
-        else:
-            inputs.tensor_split[n] = 0
-
-    # we must force an explicit tensor split
-    # otherwise the default will divide equally and multigpu crap will slow it down badly
-    inputs.cublas_info = 0
-
-    if not args.tensor_split:
-        if (args.usecublas and "0" in args.usecublas):
-            os.environ["CUDA_VISIBLE_DEVICES"] = "0"
-            os.environ["HIP_VISIBLE_DEVICES"] = "0"
-        elif (args.usecublas and "1" in args.usecublas):
-            os.environ["CUDA_VISIBLE_DEVICES"] = "1"
-            os.environ["HIP_VISIBLE_DEVICES"] = "1"
-        elif (args.usecublas and "2" in args.usecublas):
-            os.environ["CUDA_VISIBLE_DEVICES"] = "2"
-            os.environ["HIP_VISIBLE_DEVICES"] = "2"
-        elif (args.usecublas and "3" in args.usecublas):
-            os.environ["CUDA_VISIBLE_DEVICES"] = "3"
-            os.environ["HIP_VISIBLE_DEVICES"] = "3"
-    else:
-        if (args.usecublas and "0" in args.usecublas):
-            inputs.cublas_info = 0
-        elif (args.usecublas and "1" in args.usecublas):
-            inputs.cublas_info = 1
-        elif (args.usecublas and "2" in args.usecublas):
-            inputs.cublas_info = 2
-        elif (args.usecublas and "3" in args.usecublas):
-            inputs.cublas_info = 3
-
-    inputs.executable_path = (getdirpath()+"/").encode("UTF-8")
-    inputs.debugmode = args.debugmode
-    banned_tokens = args.bantokens
-    for n in range(ban_token_max):
-        if not banned_tokens or n >= len(banned_tokens):
-            inputs.banned_tokens[n] = "".encode("UTF-8")
-        else:
-            inputs.banned_tokens[n] = banned_tokens[n].encode("UTF-8")
-    ret = handle.load_model(inputs)
-    return ret
-
-def generate(prompt,max_length=20, max_context_length=512, temperature=0.8, top_k=120, top_a=0.0, top_p=0.85, typical_p=1.0, tfs=1.0, rep_pen=1.1, rep_pen_range=128, mirostat=0, mirostat_tau=5.0, mirostat_eta=0.1, sampler_order=[6,0,1,3,4,2,5], seed=-1, stop_sequence=[], use_default_badwordsids=False, stream_sse=False, grammar='', grammar_retain_state=False, genkey=''):
-    global maxctx, args, currentusergenkey, totalgens
-    inputs = generation_inputs()
-    outputs = ctypes.create_unicode_buffer(ctypes.sizeof(generation_outputs))
-    inputs.prompt = prompt.encode("UTF-8")
-    if max_length >= max_context_length:
-        max_length = max_context_length-1
-    inputs.max_context_length = max_context_length   # this will resize the context buffer if changed
-    global showmaxctxwarning
-    if showmaxctxwarning and max_context_length > maxctx:
-        print(f"\n(Warning! Request max_context_length={max_context_length} exceeds allocated context size of {maxctx}. Consider launching with increased --contextsize to avoid errors. This message will only show once per session.)")
-        showmaxctxwarning = False
-    inputs.max_length = max_length
-    inputs.temperature = temperature
-    inputs.top_k = top_k
-    inputs.top_a = top_a
-    inputs.top_p = top_p
-    inputs.typical_p = typical_p
-    inputs.tfs = tfs
-    inputs.rep_pen = rep_pen
-    inputs.rep_pen_range = rep_pen_range
-    inputs.stream_sse = stream_sse
-    inputs.grammar = grammar.encode("UTF-8")
-    inputs.grammar_retain_state = grammar_retain_state
-    inputs.unban_tokens_rt = not use_default_badwordsids
-    if mirostat in (1, 2):
-        inputs.mirostat = mirostat
-        inputs.mirostat_tau = mirostat_tau
-        inputs.mirostat_eta = mirostat_eta
-    else:
-        inputs.mirostat = inputs.mirostat_tau = inputs.mirostat_eta = 0
-    if sampler_order and 0 < len(sampler_order) <= sampler_order_max:
-        try:
-            for i, sampler in enumerate(sampler_order):
-                inputs.sampler_order[i] = sampler
-            inputs.sampler_len = len(sampler_order)
-            global showsamplerwarning
-            if showsamplerwarning and inputs.mirostat==0 and inputs.sampler_len>0 and (inputs.sampler_order[0]!=6 or inputs.sampler_order[inputs.sampler_len-1]!=5):
-                print("\n(Note: Sub-optimal sampler_order detected. You may have reduced quality. Recommended sampler values are [6,0,1,3,4,2,5]. This message will only show once per session.)")
-                showsamplerwarning = False
-        except TypeError as e:
-            print("ERROR: sampler_order must be a list of integers: " + str(e))
-    inputs.seed = seed
-    for n in range(stop_token_max):
-        if not stop_sequence or n >= len(stop_sequence):
-            inputs.stop_sequence[n] = "".encode("UTF-8")
-        else:
-            inputs.stop_sequence[n] = stop_sequence[n].encode("UTF-8")
-    currentusergenkey = genkey
-    totalgens += 1
-    ret = handle.generate(inputs,outputs)
-    if(ret.status==1):
-        return ret.text.decode("UTF-8","ignore")
-    return ""
-
-def utfprint(str):
-    try:
-        print(str)
-    except UnicodeEncodeError:
-        # Replace or omit the problematic character
-        utf_string = str.encode('ascii', 'ignore').decode('ascii')
-        utf_string = utf_string.replace('\a', '') #remove bell characters
-        print(utf_string)
-
-def bring_terminal_to_foreground():
-    if os.name=='nt':
-        ctypes.windll.user32.ShowWindow(ctypes.windll.kernel32.GetConsoleWindow(), 9)
-        ctypes.windll.user32.SetForegroundWindow(ctypes.windll.kernel32.GetConsoleWindow())
-
-
-#################################################################
-### A hacky simple HTTP server simulating a kobold api by Concedo
-### we are intentionally NOT using flask, because we want MINIMAL dependencies
-#################################################################
-friendlymodelname = "concedo/koboldcpp"  # local kobold api apparently needs a hardcoded known HF model name
-maxctx = 2048
-maxhordectx = 1024
-maxhordelen = 256
-modelbusy = threading.Lock()
-requestsinqueue = 0
-defaultport = 5001
-KcppVersion = "1.46.1"
-showdebug = True
-showsamplerwarning = True
-showmaxctxwarning = True
-session_kudos_earned = 0
-session_jobs = 0
-session_starttime = None
-exitcounter = 0
-totalgens = 0
-currentusergenkey = "" #store a special key so polled streaming works even in multiuser
-args = None #global args
-
-class ServerRequestHandler(http.server.SimpleHTTPRequestHandler):
-    sys_version = ""
-    server_version = "ConcedoLlamaForKoboldServer"
-
-    def __init__(self, addr, port, embedded_kailite, embedded_kcpp_docs):
-        self.addr = addr
-        self.port = port
-        self.embedded_kailite = embedded_kailite
-        self.embedded_kcpp_docs = embedded_kcpp_docs
-
-    def __call__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def log_message(self, format, *args):
-        global showdebug
-        if showdebug:
-            super().log_message(format, *args)
-        pass
-
-    async def generate_text(self, genparams, api_format, stream_flag):
-        global friendlymodelname
-        def run_blocking():
-            if api_format==1:
-                genparams["prompt"] = genparams.get('text', "")
-                genparams["top_k"] = int(genparams.get('top_k', 120))
-                genparams["max_length"] = genparams.get('max', 80)
-            elif api_format==3:
-                frqp = genparams.get('frequency_penalty', 0.1)
-                scaled_rep_pen = genparams.get('presence_penalty', frqp) + 1
-                genparams["max_length"] = genparams.get('max_tokens', 80)
-                genparams["rep_pen"] = scaled_rep_pen
-                # openai allows either a string or a list as a stop sequence
-                if isinstance(genparams.get('stop',[]), list):
-                    genparams["stop_sequence"] = genparams.get('stop', [])
-                else:
-                    genparams["stop_sequence"] = [genparams.get('stop')]
-            elif api_format==4:
-                # translate openai chat completion messages format into one big string.
-                messages_array = genparams.get('messages', [])
-                messages_string = ""
-                for message in messages_array:
-                    if message['role'] == "system":
-                        messages_string+="\n### Instruction:\n"
-                    elif message['role'] == "user":
-                        messages_string+="\n### Instruction:\n"
-                    elif message['role'] == "assistant":
-                        messages_string+="\n### Response:\n"
-                    messages_string+=message['content']
-                messages_string += "\n### Response:\n"
-                genparams["prompt"] = messages_string
-                frqp = genparams.get('frequency_penalty', 0.1)
-                scaled_rep_pen = genparams.get('presence_penalty', frqp) + 1
-                genparams["max_length"] = genparams.get('max_tokens', 80)
-                genparams["rep_pen"] = scaled_rep_pen
-                # openai allows either a string or a list as a stop sequence
-                if isinstance(genparams.get('stop',[]), list):
-                    genparams["stop_sequence"] = genparams.get('stop', [])
-                else:
-                    genparams["stop_sequence"] = [genparams.get('stop')]
-
-            return generate(
-                prompt=genparams.get('prompt', ""),
-                max_context_length=genparams.get('max_context_length', maxctx),
-                max_length=genparams.get('max_length', 80),
-                temperature=genparams.get('temperature', 0.8),
-                top_k=genparams.get('top_k', 120),
-                top_a=genparams.get('top_a', 0.0),
-                top_p=genparams.get('top_p', 0.85),
-                typical_p=genparams.get('typical', 1.0),
-                tfs=genparams.get('tfs', 1.0),
-                rep_pen=genparams.get('rep_pen', 1.1),
-                rep_pen_range=genparams.get('rep_pen_range', 256),
-                mirostat=genparams.get('mirostat', 0),
-                mirostat_tau=genparams.get('mirostat_tau', 5.0),
-                mirostat_eta=genparams.get('mirostat_eta', 0.1),
-                sampler_order=genparams.get('sampler_order', [6,0,1,3,4,2,5]),
-                seed=genparams.get('sampler_seed', -1),
-                stop_sequence=genparams.get('stop_sequence', []),
-                use_default_badwordsids=genparams.get('use_default_badwordsids', False),
-                stream_sse=stream_flag,
-                grammar=genparams.get('grammar', ''),
-                grammar_retain_state = genparams.get('grammar_retain_state', False),
-                genkey=genparams.get('genkey', ''))
-
-        recvtxt = ""
-        if stream_flag:
-            loop = asyncio.get_event_loop()
-            executor = ThreadPoolExecutor()
-            recvtxt = await loop.run_in_executor(executor, run_blocking)
-        else:
-            recvtxt = run_blocking()
-
-        if args.debugmode!=-1:
-            utfprint("\nOutput: " + recvtxt)
-
-        if api_format==1:
-            res = {"data": {"seqs":[recvtxt]}}
-        elif api_format==3:
-            res = {"id": "cmpl-1", "object": "text_completion", "created": 1, "model": friendlymodelname,
-            "choices": [{"text": recvtxt, "index": 0, "finish_reason": "length"}]}
-        elif api_format==4:
-            res = {"id": "chatcmpl-1", "object": "chat.completion", "created": 1, "model": friendlymodelname,
-            "choices": [{"index": 0, "message":{"role": "assistant", "content": recvtxt,}, "finish_reason": "length"}]}
-        else:
-            res = {"results": [{"text": recvtxt}]}
-
-        try:
-            return res
-        except Exception as e:
-            print(f"Generate: Error while generating: {e}")
-
-
-    async def send_oai_sse_event(self, data):
-        self.wfile.write(f'data: {data}\r\n\r\n'.encode())
-        self.wfile.flush()
-
-    async def send_kai_sse_event(self, data):
-        self.wfile.write(f'event: message\n'.encode())
-        self.wfile.write(f'data: {data}\n\n'.encode())
-        self.wfile.flush()
-
-    async def handle_sse_stream(self, api_format):
-        global friendlymodelname
-        self.send_response(200)
-        self.send_header("Cache-Control", "no-cache")
-        self.send_header("Connection", "keep-alive")
-        self.end_headers(force_json=True, sse_stream_flag=True)
-
-        current_token = 0
-        incomplete_token_buffer = bytearray()
-        while True:
-            streamDone = handle.has_finished() #exit next loop on done
-            tokenStr = ""
-            streamcount = handle.get_stream_count()
-            while current_token < streamcount:
-                token = handle.new_token(current_token)
-
-                if token is None: # Token isnt ready yet, received nullpointer
-                    break
-
-                current_token += 1
-                newbyte = ctypes.string_at(token)
-                incomplete_token_buffer += bytearray(newbyte)
-                tokenSeg = incomplete_token_buffer.decode("UTF-8","ignore")
-                if tokenSeg!="":
-                    incomplete_token_buffer.clear()
-                    tokenStr += tokenSeg
-
-            if tokenStr!="":
-                if api_format == 4:  # if oai chat, set format to expected openai streaming response
-                    event_str = json.dumps({"id":"koboldcpp","object":"chat.completion.chunk","created":1,"model":friendlymodelname,"choices":[{"index":0,"finish_reason":"length","delta":{'role':'assistant','content':tokenStr}}]})
-                    await self.send_oai_sse_event(event_str)
-                else:
-                    event_str = json.dumps({"token": tokenStr})
-                    await self.send_kai_sse_event(event_str)
-                tokenStr = ""
-
-            else:
-                await asyncio.sleep(0.02) #this should keep things responsive
-
-            if streamDone:
-                if api_format == 4:  # if oai chat, send last [DONE] message consistent with openai format
-                    await self.send_oai_sse_event('[DONE]')
-                break
-
-        # flush buffers, sleep a bit to make sure all data sent, and then force close the connection
-        self.wfile.flush()
-        await asyncio.sleep(0.2)
-        self.close_connection = True
-        await asyncio.sleep(0.1)
-
-
-    async def handle_request(self, genparams, api_format, stream_flag):
-        tasks = []
-
-        if stream_flag:
-            tasks.append(self.handle_sse_stream(api_format))
-
-        generate_task = asyncio.create_task(self.generate_text(genparams, api_format, stream_flag))
-        tasks.append(generate_task)
-
-        try:
-            await asyncio.gather(*tasks)
-            generate_result = generate_task.result()
-            return generate_result
-        except Exception as e:
-            print(e)
-
-
-    def do_GET(self):
-        global maxctx, maxhordelen, friendlymodelname, KcppVersion, totalgens
-        self.path = self.path.rstrip('/')
-        response_body = None
-        force_json = False
-
-        if self.path in ["", "/?"] or self.path.startswith(('/?','?')): #it's possible for the root url to have ?params without /
-
-            if self.embedded_kailite is None:
-                response_body = (f"Embedded Kobold Lite is not found.<br>You will have to connect via the main KoboldAI client, or <a href='https://lite.koboldai.net?local=1&port={self.port}'>use this URL</a> to connect.").encode()
-            else:
-                response_body = self.embedded_kailite
-
-        elif self.path.endswith(('/api/v1/model', '/api/latest/model')):
-            response_body = (json.dumps({'result': friendlymodelname }).encode())
-
-        elif self.path.endswith(('/api/v1/config/max_length', '/api/latest/config/max_length')):
-            response_body = (json.dumps({"value": maxhordelen}).encode())
-
-        elif self.path.endswith(('/api/v1/config/max_context_length', '/api/latest/config/max_context_length')):
-            response_body = (json.dumps({"value": min(maxctx,maxhordectx)}).encode())
-
-        elif self.path.endswith(('/api/v1/config/soft_prompt', '/api/latest/config/soft_prompt')):
-            response_body = (json.dumps({"value":""}).encode())
-
-        elif self.path.endswith(('/api/v1/config/soft_prompts_list', '/api/latest/config/soft_prompts_list')):
-            response_body = (json.dumps({"values": []}).encode())
-
-        elif self.path.endswith(('/api/v1/info/version', '/api/latest/info/version')):
-            response_body = (json.dumps({"result":"1.2.5"}).encode())
-
-        elif self.path.endswith(('/api/extra/true_max_context_length')): #do not advertise this to horde
-            response_body = (json.dumps({"value": maxctx}).encode())
-
-        elif self.path.endswith(('/api/extra/version')):
-            response_body = (json.dumps({"result":"KoboldCpp","version":KcppVersion}).encode())
-
-        elif self.path.endswith(('/api/extra/perf')):
-            lastp = handle.get_last_process_time()
-            laste = handle.get_last_eval_time()
-            lastc = handle.get_last_token_count()
-            stopreason = handle.get_last_stop_reason()
-            response_body = (json.dumps({"last_process":lastp,"last_eval":laste,"last_token_count":lastc, "stop_reason":stopreason, "queue":requestsinqueue, "idle":(0 if modelbusy.locked() else 1)}).encode())
-
-        elif self.path.endswith('/api/extra/generate/check'):
-            pendtxtStr = ""
-            if requestsinqueue==0 and totalgens>0:
-                pendtxt = handle.get_pending_output()
-                pendtxtStr = ctypes.string_at(pendtxt).decode("UTF-8","ignore")
-            response_body = (json.dumps({"results": [{"text": pendtxtStr}]}).encode())
-
-        elif self.path.endswith('/v1/models'):
-            response_body = (json.dumps({"object":"list","data":[{"id":friendlymodelname,"object":"model","created":1,"owned_by":"koboldcpp","permission":[],"root":"koboldcpp"}]}).encode())
-            force_json = True
-
-        elif self.path=="/api":
-            if self.embedded_kcpp_docs is None:
-                response_body = (f"KoboldCpp partial API reference can be found at the wiki: https://github.com/LostRuins/koboldcpp/wiki").encode()
-            else:
-                response_body = self.embedded_kcpp_docs
-        elif self.path.endswith(('/api')) or self.path.endswith(('/api/v1')):
-            self.path = "/api"
-            self.send_response(302)
-            self.send_header("Location", self.path)
-            self.end_headers()
-            return None
-
-        if response_body is None:
-            self.send_response(404)
-            self.end_headers()
-            rp = 'Error: HTTP Server is running, but this endpoint does not exist. Please check the URL.'
-            self.wfile.write(rp.encode())
-        else:
-            self.send_response(200)
-            self.send_header('Content-Length', str(len(response_body)))
-            self.end_headers(force_json=force_json)
-            self.wfile.write(response_body)
-        return
-
-    def do_POST(self):
-        global modelbusy, requestsinqueue, currentusergenkey, totalgens
-        content_length = int(self.headers['Content-Length'])
-        body = self.rfile.read(content_length)
-        self.path = self.path.rstrip('/')
-        force_json = False
-        if self.path.endswith(('/api/extra/tokencount')):
-            try:
-                genparams = json.loads(body)
-                countprompt = genparams.get('prompt', "")
-                count = handle.token_count(countprompt.encode("UTF-8"))
-                self.send_response(200)
-                self.end_headers()
-                self.wfile.write(json.dumps({"value": count}).encode())
-
-            except ValueError as e:
-                utfprint("Count Tokens - Body Error: " + str(e))
-                self.send_response(400)
-                self.end_headers()
-                self.wfile.write(json.dumps({"value": -1}).encode())
-            return
-
-        if self.path.endswith('/api/extra/abort'):
-            multiuserkey = ""
-            try:
-                tempbody = json.loads(body)
-                multiuserkey = tempbody.get('genkey', "")
-            except ValueError as e:
-                multiuserkey = ""
-                pass
-
-            if (multiuserkey!="" and multiuserkey==currentusergenkey) or requestsinqueue==0:
-                ag = handle.abort_generate()
-                time.sleep(0.3) #short delay before replying
-                self.send_response(200)
-                self.end_headers()
-                self.wfile.write(json.dumps({"success": ("true" if ag else "false")}).encode())
-                print("\nGeneration Aborted")
-            else:
-                self.wfile.write(json.dumps({"success": "false"}).encode())
-            return
-
-        if self.path.endswith('/api/extra/generate/check'):
-            pendtxtStr = ""
-            multiuserkey = ""
-            try:
-                tempbody = json.loads(body)
-                multiuserkey = tempbody.get('genkey', "")
-            except ValueError as e:
-                multiuserkey = ""
-                pass
-
-            if totalgens>0:
-                if (multiuserkey!="" and multiuserkey==currentusergenkey) or requestsinqueue==0:
-                    pendtxt = handle.get_pending_output()
-                    pendtxtStr = ctypes.string_at(pendtxt).decode("UTF-8","ignore")
-            self.send_response(200)
-            self.end_headers()
-            self.wfile.write(json.dumps({"results": [{"text": pendtxtStr}]}).encode())
-            return
-
-        reqblocking = False
-        if args.multiuser and requestsinqueue < 4: #up to 5 concurrent requests
-            reqblocking = True
-            requestsinqueue += 1
-        if not modelbusy.acquire(blocking=reqblocking):
-            self.send_response(503)
-            self.end_headers()
-            self.wfile.write(json.dumps({"detail": {
-                    "msg": "Server is busy; please try again later.",
-                    "type": "service_unavailable",
-                }}).encode())
-            return
-        if reqblocking:
-            requestsinqueue = (requestsinqueue - 1) if requestsinqueue > 0 else 0
-
-        try:
-            sse_stream_flag = False
-
-            api_format = 0 #1=basic,2=kai,3=oai,4=oai-chat
-
-            if self.path.endswith('/request'):
-                api_format = 1
-
-            if self.path.endswith(('/api/v1/generate', '/api/latest/generate')):
-                api_format = 2
-
-            if self.path.endswith('/api/extra/generate/stream'):
-                api_format = 2
-                sse_stream_flag = True
-
-            if self.path.endswith('/v1/completions'):
-                api_format = 3
-                force_json = True
-
-            if self.path.endswith('/v1/chat/completions'):
-                api_format = 4
-                force_json = True
-
-            if api_format > 0:
-                genparams = None
-                try:
-                    genparams = json.loads(body)
-                except ValueError as e:
-                    utfprint("Body Err: " + str(body))
-                    return self.send_response(503)
-
-                if args.debugmode!=-1:
-                    utfprint("\nInput: " + json.dumps(genparams))
-
-                if args.foreground:
-                    bring_terminal_to_foreground()
-
-                # Check if streaming chat completions, if so, set stream mode to true
-                if api_format == 4 and "stream" in genparams and genparams["stream"]:
-                    sse_stream_flag = True
-
-                gen = asyncio.run(self.handle_request(genparams, api_format, sse_stream_flag))
-
-                try:
-                    # Headers are already sent when streaming
-                    if not sse_stream_flag:
-                        self.send_response(200)
-                        self.end_headers(force_json=force_json)
-                    self.wfile.write(json.dumps(gen).encode())
-                except:
-                    print("Generate: The response could not be sent, maybe connection was terminated?")
-                return
-        finally:
-            modelbusy.release()
-
-        self.send_response(404)
-        self.end_headers()
-
-
-    def do_OPTIONS(self):
-        self.send_response(200)
-        self.end_headers()
-
-    def do_HEAD(self):
-        self.send_response(200)
-        self.end_headers()
-
-    def end_headers(self, force_json=False, sse_stream_flag=False):
-        self.send_header('Access-Control-Allow-Origin', '*')
-        self.send_header('Access-Control-Allow-Methods', '*')
-        self.send_header('Access-Control-Allow-Headers', '*')
-        if ("/api" in self.path and self.path!="/api") or force_json:
-            if sse_stream_flag:
-                self.send_header('Content-type', 'text/event-stream')
-            self.send_header('Content-type', 'application/json')
-        else:
-            self.send_header('Content-type', 'text/html')
-        return super(ServerRequestHandler, self).end_headers()
-
-
-def RunServerMultiThreaded(addr, port, embedded_kailite = None, embedded_kcpp_docs = None):
-    global exitcounter
-    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    sock.bind((addr, port))
-    sock.listen(5)
-
-    class Thread(threading.Thread):
-        def __init__(self, i):
-            threading.Thread.__init__(self)
-            self.i = i
-            self.daemon = True
-            self.start()
-
-        def run(self):
-            global exitcounter
-            handler = ServerRequestHandler(addr, port, embedded_kailite, embedded_kcpp_docs)
-            with http.server.HTTPServer((addr, port), handler, False) as self.httpd:
-                try:
-                    self.httpd.socket = sock
-                    self.httpd.server_bind = self.server_close = lambda self: None
-                    self.httpd.serve_forever()
-                except (KeyboardInterrupt,SystemExit):
-                    exitcounter = 999
-                    self.httpd.server_close()
-                    sys.exit(0)
-                finally:
-                    exitcounter = 999
-                    self.httpd.server_close()
-                    sys.exit(0)
-        def stop(self):
-            global exitcounter
-            exitcounter = 999
-            self.httpd.server_close()
-
-    numThreads = 12
-    threadArr = []
-    for i in range(numThreads):
-        threadArr.append(Thread(i))
-    while 1:
-        try:
-            time.sleep(10)
-        except KeyboardInterrupt:
-            exitcounter = 999
-            for i in range(numThreads):
-                threadArr[i].stop()
-            sys.exit(0)
-
-# note: customtkinter-5.2.0
-def show_new_gui():
-    from tkinter.filedialog import askopenfilename
-    from tkinter.filedialog import asksaveasfile
-
-    # if args received, launch
-    if len(sys.argv) != 1:
-        import tkinter as tk
-        root = tk.Tk() #we dont want the useless window to be visible, but we want it in taskbar
-        root.attributes("-alpha", 0)
-        args.model_param = askopenfilename(title="Select ggml model .bin or .gguf file or .kcpps config")
-        root.destroy()
-        if args.model_param and args.model_param!="" and args.model_param.lower().endswith('.kcpps'):
-            loadconfigfile(args.model_param)
-        if not args.model_param:
-            print("\nNo ggml model or kcpps file was selected. Exiting.")
-            time.sleep(3)
-            sys.exit(2)
-        return
-
-    import customtkinter as ctk
-    nextstate = 0 #0=exit, 1=launch
-    windowwidth = 530
-    windowheight = 500
-    ctk.set_appearance_mode("dark")
-    root = ctk.CTk()
-    root.geometry(str(windowwidth) + "x" + str(windowheight))
-    root.title("KoboldCpp v"+KcppVersion)
-    root.resizable(False,False)
-
-    tabs = ctk.CTkFrame(root, corner_radius = 0, width=windowwidth, height=windowheight-50)
-    tabs.grid(row=0, stick="nsew")
-    tabnames= ["Quick Launch", "Hardware", "Tokens", "Model", "Network"]
-    navbuttons = {}
-    navbuttonframe = ctk.CTkFrame(tabs, width=100, height=int(tabs.cget("height")))
-    navbuttonframe.grid(row=0, column=0, padx=2,pady=2)
-    navbuttonframe.grid_propagate(False)
-
-    tabcontentframe = ctk.CTkFrame(tabs, width=windowwidth - int(navbuttonframe.cget("width")), height=int(tabs.cget("height")))
-    tabcontentframe.grid(row=0, column=1, sticky="nsew", padx=2, pady=2)
-    tabcontentframe.grid_propagate(False)
-
-    tabcontent = {}
-    lib_option_pairs = [
-        (lib_openblas, "Use OpenBLAS"),
-        (lib_clblast, "Use CLBlast"),
-        (lib_cublas, "Use CuBLAS"),
-        (lib_hipblas, "Use hipBLAS (ROCm)"),
-        (lib_default, "Use No BLAS"),
-        (lib_noavx2, "NoAVX2 Mode (Old CPU)"),
-        (lib_failsafe, "Failsafe Mode (Old CPU)")]
-    openblas_option, clblast_option, cublas_option, hipblas_option, default_option, noavx2_option, failsafe_option = (opt if file_exists(lib) or (os.name == 'nt' and file_exists(opt + ".dll")) else None for lib, opt in lib_option_pairs)
-    # slider data
-    blasbatchsize_values = ["-1", "32", "64", "128", "256", "512", "1024", "2048"]
-    blasbatchsize_text = ["Don't Batch BLAS","32","64","128","256","512","1024","2048"]
-    contextsize_text = ["512", "1024", "2048", "3072", "4096", "6144", "8192", "12288", "16384", "24576", "32768", "65536"]
-    runopts = [opt for lib, opt in lib_option_pairs if file_exists(lib)]
-    antirunopts = [opt.replace("Use ", "") for lib, opt in lib_option_pairs if not (opt in runopts)]
-    if not any(runopts):
-        show_gui_msgbox("No Backends Available!","KoboldCPP couldn't locate any backends to use (i.e Default, OpenBLAS, CLBlast, CuBLAS).\n\nTo use the program, please run the 'make' command from the directory.")
-        time.sleep(3)
-        sys.exit(2)
-    def tabbuttonaction(name):
-        for t in tabcontent:
-            if name == t:
-                tabcontent[t].grid(row=0, column=0)
-                navbuttons[t].configure(fg_color="#6f727b")
-            else:
-                tabcontent[t].grid_forget()
-                navbuttons[t].configure(fg_color="transparent")
-
-    # Dynamically create tabs + buttons based on values of [tabnames]
-    for idx, name in enumerate(tabnames):
-        tabcontent[name] = ctk.CTkFrame(tabcontentframe, width=int(tabcontentframe.cget("width")), height=int(tabcontentframe.cget("height")), fg_color="transparent")
-        tabcontent[name].grid_propagate(False)
-        if idx == 0:
-            tabcontent[name].grid(row=idx, sticky="nsew")
-        ctk.CTkLabel(tabcontent[name], text= name, font=ctk.CTkFont(None, 14, 'bold')).grid(row=0, padx=12, pady = 5, stick='nw')
-
-        navbuttons[name] = ctk.CTkButton(navbuttonframe, text=name, width = 100, corner_radius=0 , command = lambda d=name:tabbuttonaction(d), hover_color="#868a94" )
-        navbuttons[name].grid(row=idx)
-
-    tabbuttonaction(tabnames[0])
-
-    # helper functions
-    def makecheckbox(parent, text, variable=None, row=0, column=0, command=None, onvalue=1, offvalue=0):
-        temp = ctk.CTkCheckBox(parent, text=text,variable=variable, onvalue=onvalue, offvalue=offvalue)
-        if command is not None and variable is not None:
-            variable.trace("w", command)
-        temp.grid(row=row,column=column, padx=8, pady=1, stick="nw")
-        return temp
-
-    def makelabel(parent, text, row, column=0):
-        temp = ctk.CTkLabel(parent, text=text)
-        temp.grid(row=row, column=column, padx=8, pady=1, stick="nw")
-        return temp
-
-    def makeslider(parent, label, options, var, from_ , to,  row=0, width=160, height=10, set=0):
-        sliderLabel = makelabel(parent, options[set], row + 1, 1)
-        makelabel(parent, label, row)
-
-        def sliderUpdate(a,b,c):
-            sliderLabel.configure(text = options[int(var.get())])
-        var.trace("w", sliderUpdate)
-        slider = ctk.CTkSlider(parent, from_=from_, to=to, variable = var, width = width, height=height, border_width=5,number_of_steps=len(options) - 1)
-        slider.grid(row=row+1,  column=0, padx = 8, stick="w")
-        slider.set(set)
-        return slider
-
-
-    def makelabelentry(parent, text, var, row=0, width= 50):
-        label = makelabel(parent, text, row)
-        entry = ctk.CTkEntry(parent, width=width, textvariable=var) #you cannot set placeholder text for SHARED variables
-        entry.grid(row=row, column=1, padx= 8, stick="nw")
-        return entry, label
-
-
-    def makefileentry(parent, text, searchtext, var, row=0, width=250, filetypes=[]):
-        makelabel(parent, text, row)
-        def getfilename(var, text):
-            var.set(askopenfilename(title=text,filetypes=filetypes))
-        entry = ctk.CTkEntry(parent, width, textvariable=var)
-        entry.grid(row=row+1, column=0, padx=8, stick="nw")
-        button = ctk.CTkButton(parent, 50, text="Browse", command= lambda a=var,b=searchtext:getfilename(a,b))
-        button.grid(row=row+1, column=1, stick="nw")
-        return
-
-    def show_tooltip(event, tooltip_text=None):
-        if hasattr(show_tooltip, "_tooltip"):
-            tooltip = show_tooltip._tooltip
-        else:
-            tooltip = ctk.CTkToplevel(root)
-            tooltip.configure(fg_color="#ffffe0")
-            tooltip.withdraw()
-            tooltip.overrideredirect(True)
-            tooltip_label = ctk.CTkLabel(tooltip, text=tooltip_text, text_color="#000000", fg_color="#ffffe0")
-            tooltip_label.pack(expand=True, padx=2, pady=1)
-            show_tooltip._tooltip = tooltip
-        x, y = root.winfo_pointerxy()
-        tooltip.wm_geometry(f"+{x + 10}+{y + 10}")
-        tooltip.deiconify()
-
-    def hide_tooltip(event):
-        if hasattr(show_tooltip, "_tooltip"):
-            tooltip = show_tooltip._tooltip
-            tooltip.withdraw()
-
-    def setup_backend_tooltip(parent):
-        num_backends_built = makelabel(parent, str(len(runopts)) + "/6", 5, 2)
-        num_backends_built.grid(row=1, column=2, padx=0, pady=0)
-        num_backends_built.configure(text_color="#00ff00")
-        # Bind the backend count label with the tooltip function
-        num_backends_built.bind("<Enter>", lambda event: show_tooltip(event, f"This is the number of backends you have built and available." + (f"\nMissing: {', '.join(antirunopts)}" if len(runopts) != 6 else "")))
-        num_backends_built.bind("<Leave>", hide_tooltip)
-
-    # Vars - should be in scope to be used by multiple widgets
-    gpulayers_var = ctk.StringVar(value="0")
-    threads_var = ctk.StringVar(value=str(default_threads))
-    runopts_var = ctk.StringVar()
-    gpu_choice_var = ctk.StringVar(value="1")
-
-    launchbrowser = ctk.IntVar(value=1)
-    highpriority = ctk.IntVar()
-    disablemmap = ctk.IntVar()
-    usemlock = ctk.IntVar()
-    debugmode = ctk.IntVar()
-    keepforeground = ctk.IntVar()
-
-    lowvram_var = ctk.IntVar()
-    mmq_var = ctk.IntVar(value=1)
-    blas_threads_var = ctk.StringVar()
-    blas_size_var = ctk.IntVar()
-    version_var =ctk.StringVar(value="0")
-
-    smartcontext = ctk.IntVar()
-    context_var = ctk.IntVar()
-    customrope_var = ctk.IntVar()
-    customrope_scale = ctk.StringVar(value="1.0")
-    customrope_base = ctk.StringVar(value="10000")
-
-    model_var = ctk.StringVar()
-    lora_var = ctk.StringVar()
-    lora_base_var  = ctk.StringVar()
-
-    port_var = ctk.StringVar(value=defaultport)
-    host_var = ctk.StringVar(value="")
-    multiuser_var = ctk.IntVar()
-    horde_name_var = ctk.StringVar(value="koboldcpp")
-    horde_gen_var = ctk.StringVar(value=maxhordelen)
-    horde_context_var = ctk.StringVar(value=maxhordectx)
-    horde_apikey_var = ctk.StringVar(value="")
-    horde_workername_var = ctk.StringVar(value="")
-    usehorde_var = ctk.IntVar()
-
-    # Quick Launch Tab
-    quick_tab = tabcontent["Quick Launch"]
-
-
-    def changerunmode(a,b,c):
-        index = runopts_var.get()
-        if index == "Use CLBlast" or index == "Use CuBLAS" or index == "Use hipBLAS (ROCm)":
-            gpu_selector_label.grid(row=3, column=0, padx = 8, pady=1, stick="nw")
-            quick_gpu_selector_label.grid(row=3, column=0, padx = 8, pady=1, stick="nw")
-            if index == "Use CLBlast":
-                gpu_selector_box.grid(row=3, column=1, padx=8, pady=1, stick="nw")
-                quick_gpu_selector_box.grid(row=3, column=1, padx=8, pady=1, stick="nw")
-                if gpu_choice_var.get()=="All":
-                    gpu_choice_var.set("1")
-            elif index == "Use CuBLAS" or index == "Use hipBLAS (ROCm)":
-                CUDA_gpu_selector_box.grid(row=3, column=1, padx=8, pady=1, stick="nw")
-                CUDA_quick_gpu_selector_box.grid(row=3, column=1, padx=8, pady=1, stick="nw")
-        else:
-            gpu_selector_label.grid_forget()
-            gpu_selector_box.grid_forget()
-            CUDA_gpu_selector_box.grid_forget()
-            quick_gpu_selector_label.grid_forget()
-            quick_gpu_selector_box.grid_forget()
-            CUDA_quick_gpu_selector_box.grid_forget()
-
-        if index == "Use CuBLAS" or index == "Use hipBLAS (ROCm)":
-            lowvram_box.grid(row=4, column=0, padx=8, pady=1,  stick="nw")
-            quick_lowvram_box.grid(row=4, column=0, padx=8, pady=1,  stick="nw")
-            mmq_box.grid(row=4, column=1, padx=8, pady=1,  stick="nw")
-            quick_mmq_box.grid(row=4, column=1, padx=8, pady=1,  stick="nw")
-        else:
-            lowvram_box.grid_forget()
-            quick_lowvram_box.grid_forget()
-            mmq_box.grid_forget()
-            quick_mmq_box.grid_forget()
-
-        if index == "Use CLBlast" or index == "Use CuBLAS" or index == "Use hipBLAS (ROCm)":
-            gpu_layers_label.grid(row=5, column=0, padx = 8, pady=1, stick="nw")
-            gpu_layers_entry.grid(row=5, column=1, padx=8, pady=1, stick="nw")
-            quick_gpu_layers_label.grid(row=5, column=0, padx = 8, pady=1, stick="nw")
-            quick_gpu_layers_entry.grid(row=5, column=1, padx=8, pady=1, stick="nw")
-        else:
-            gpu_layers_label.grid_forget()
-            gpu_layers_entry.grid_forget()
-            quick_gpu_layers_label.grid_forget()
-            quick_gpu_layers_entry.grid_forget()
-
-    # presets selector
-    makelabel(quick_tab, "Presets:", 1)
-
-    runoptbox = ctk.CTkComboBox(quick_tab, values=runopts, width=180,variable=runopts_var, state="readonly")
-    runoptbox.grid(row=1, column=1,padx=8, stick="nw")
-    runoptbox.set(runopts[0]) # Set to first available option
-
-    # Tell user how many backends are available
-    setup_backend_tooltip(quick_tab)
-
-    # gpu options
-    quick_gpu_selector_label = makelabel(quick_tab, "GPU ID:", 3)
-    quick_gpu_selector_box = ctk.CTkComboBox(quick_tab, values=["1","2","3","4"], width=60, variable=gpu_choice_var, state="readonly")
-    CUDA_quick_gpu_selector_box = ctk.CTkComboBox(quick_tab, values=["1","2","3","4","All"], width=60, variable=gpu_choice_var, state="readonly")
-    quick_gpu_layers_entry,quick_gpu_layers_label = makelabelentry(quick_tab,"GPU Layers:", gpulayers_var, 5, 50)
-    quick_lowvram_box = makecheckbox(quick_tab,  "Low VRAM", lowvram_var, 4,0)
-    quick_mmq_box = makecheckbox(quick_tab,  "Use QuantMatMul (mmq)", mmq_var, 4,1)
-
-    # threads
-    makelabelentry(quick_tab, "Threads:" , threads_var, 8, 50)
-
-    # blas batch size
-    makeslider(quick_tab, "BLAS Batch Size:", blasbatchsize_text, blas_size_var, 0, 7, 12, set=5)
-
-    # quick boxes
-    quick_boxes = {"Launch Browser": launchbrowser , "High Priority" : highpriority, "Use SmartContext":smartcontext, "Disable MMAP":disablemmap,}
-    for idx, name, in enumerate(quick_boxes):
-        makecheckbox(quick_tab, name, quick_boxes[name], int(idx/2) +20, idx%2)
-    # context size
-    makeslider(quick_tab, "Context Size:", contextsize_text, context_var, 0, len(contextsize_text)-1, 30, set=2)
-
-    # load model
-    makefileentry(quick_tab, "Model:", "Select GGML Model File", model_var, 40, 170,filetypes=[("GGML Model Files", "*.gguf;*.bin;*.ggml")])
-
-    # Hardware Tab
-    hardware_tab = tabcontent["Hardware"]
-
-    # presets selector
-    makelabel(hardware_tab, "Presets:", 1)
-    runoptbox = ctk.CTkComboBox(hardware_tab, values=runopts,  width=180,variable=runopts_var, state="readonly")
-    runoptbox.grid(row=1, column=1,padx=8, stick="nw")
-    runoptbox.set(runopts[0]) # Set to first available option
-
-    # Tell user how many backends are available
-    setup_backend_tooltip(hardware_tab)
-
-    # gpu options
-    gpu_selector_label = makelabel(hardware_tab, "GPU ID:", 3)
-    gpu_selector_box = ctk.CTkComboBox(hardware_tab, values=["1","2","3","4"], width=60, variable=gpu_choice_var, state="readonly")
-    CUDA_gpu_selector_box = ctk.CTkComboBox(hardware_tab, values=["1","2","3","4", "All"], width=60, variable=gpu_choice_var, state="readonly")
-    gpu_layers_entry,gpu_layers_label = makelabelentry(hardware_tab,"GPU Layers:", gpulayers_var, 5, 50)
-    lowvram_box = makecheckbox(hardware_tab,  "Low VRAM", lowvram_var, 4,0)
-    mmq_box = makecheckbox(hardware_tab,  "Use QuantMatMul (mmq)", mmq_var, 4,1)
-
-    # threads
-    makelabelentry(hardware_tab, "Threads:" , threads_var, 8, 50)
-
-    # hardware checkboxes
-    hardware_boxes = {"Launch Browser": launchbrowser , "High Priority" : highpriority, "Disable MMAP":disablemmap, "Use mlock":usemlock, "Debug Mode":debugmode, "Keep Foreground":keepforeground}
-
-    for idx, name, in enumerate(hardware_boxes):
-        makecheckbox(hardware_tab, name, hardware_boxes[name], int(idx/2) +30, idx%2)
-
-    # blas thread specifier
-    makelabelentry(hardware_tab, "BLAS threads:" , blas_threads_var, 11, 50)
-    # blas batch size
-    makeslider(hardware_tab, "BLAS Batch Size:", blasbatchsize_text, blas_size_var, 0, 7, 12, set=5)
-    # force version
-    makelabelentry(hardware_tab, "Force Version:" , version_var, 100, 50)
-
-    runopts_var.trace('w', changerunmode)
-    changerunmode(1,1,1)
-
-    # Tokens Tab
-    tokens_tab = tabcontent["Tokens"]
-    # tokens checkboxes
-    token_boxes = {"Use SmartContext":smartcontext}
-    for idx, name, in enumerate(token_boxes):
-        makecheckbox(tokens_tab, name, token_boxes[name], idx + 1)
-
-    # context size
-    makeslider(tokens_tab, "Context Size:",contextsize_text, context_var, 0, len(contextsize_text)-1, 20, set=2)
-
-
-    customrope_scale_entry, customrope_scale_label = makelabelentry(tokens_tab, "RoPE Scale:", customrope_scale)
-    customrope_base_entry, customrope_base_label = makelabelentry(tokens_tab, "RoPE Base:", customrope_base)
-    def togglerope(a,b,c):
-        items = [customrope_scale_label, customrope_scale_entry,customrope_base_label, customrope_base_entry]
-        for idx, item in enumerate(items):
-            if customrope_var.get() == 1:
-                item.grid(row=23 + int(idx/2), column=idx%2, padx=8, stick="nw")
-            else:
-                item.grid_forget()
-    makecheckbox(tokens_tab,  "Custom RoPE Config", variable=customrope_var, row=22, command=togglerope)
-    togglerope(1,1,1)
-
-    # Model Tab
-    model_tab = tabcontent["Model"]
-
-    makefileentry(model_tab, "Model:", "Select GGML Model File", model_var, 1, filetypes=[("GGML Model Files", "*.gguf;*.bin;*.ggml")])
-    makefileentry(model_tab, "Lora:", "Select Lora File",lora_var, 3)
-    makefileentry(model_tab, "Lora Base:", "Select Lora Base File", lora_base_var, 5)
-
-    # Network Tab
-    network_tab = tabcontent["Network"]
-
-    # interfaces
-    makelabelentry(network_tab, "Port: ", port_var, 1, 150)
-    makelabelentry(network_tab, "Host: ", host_var, 2, 150)
-
-    makecheckbox(network_tab, "Multiuser Mode", multiuser_var, 3)
-
-    # horde
-    makelabel(network_tab, "Horde:", 5).grid(pady=10)
-
-    horde_name_entry,  horde_name_label = makelabelentry(network_tab, "Horde Model Name:", horde_name_var, 10, 180)
-    horde_gen_entry,  horde_gen_label = makelabelentry(network_tab, "Gen. Length:", horde_gen_var, 11, 50)
-    horde_context_entry,  horde_context_label = makelabelentry(network_tab, "Max Context:",horde_context_var, 12, 50)
-    horde_apikey_entry,  horde_apikey_label = makelabelentry(network_tab, "API Key (If Embedded Worker):",horde_apikey_var, 13, 180)
-    horde_workername_entry,  horde_workername_label = makelabelentry(network_tab, "Horde Worker Name:",horde_workername_var, 14, 180)
-
-    def togglehorde(a,b,c):
-        labels = [horde_name_label, horde_gen_label, horde_context_label, horde_apikey_label, horde_workername_label]
-        for idx, item in enumerate([horde_name_entry, horde_gen_entry, horde_context_entry, horde_apikey_entry, horde_workername_entry]):
-            if usehorde_var.get() == 1:
-                item.grid(row=10 + idx, column = 1, padx=8, pady=1, stick="nw")
-                labels[idx].grid(row=10 + idx, padx=8, pady=1, stick="nw")
-            else:
-                item.grid_forget()
-                labels[idx].grid_forget()
-        if usehorde_var.get()==1 and (horde_name_var.get()=="koboldcpp" or horde_name_var.get()=="") and model_var.get()!="":
-            basefile = os.path.basename(model_var.get())
-            horde_name_var.set(os.path.splitext(basefile)[0])
-
-    makecheckbox(network_tab, "Configure for Horde", usehorde_var, 6, command=togglehorde)
-    togglehorde(1,1,1)
-
-    # launch
-    def guilaunch():
-        if model_var.get() == "":
-            tmp = askopenfilename(title="Select ggml model .bin or .gguf file")
-            model_var.set(tmp)
-        nonlocal nextstate
-        nextstate = 1
-        root.destroy()
-        pass
-
-    def export_vars():
-        args.threads = int(threads_var.get())
-        args.usemlock   = usemlock.get() == 1
-        args.debugmode  = debugmode.get()
-        args.launch     = launchbrowser.get()==1
-        args.highpriority = highpriority.get()==1
-        args.nommap = disablemmap.get()==1
-        args.smartcontext = smartcontext.get()==1
-        args.foreground = keepforeground.get()==1
-
-        gpuchoiceidx = 0
-        if gpu_choice_var.get()!="All":
-            gpuchoiceidx = int(gpu_choice_var.get())-1
-        if runopts_var.get() == "Use CLBlast":
-            args.useclblast = [[0,0], [1,0], [0,1], [1,1]][gpuchoiceidx]
-        if runopts_var.get() == "Use CuBLAS" or runopts_var.get() == "Use hipBLAS (ROCm)":
-            if gpu_choice_var.get()=="All":
-                args.usecublas = ["lowvram"] if lowvram_var.get() == 1 else ["normal"]
-            else:
-                args.usecublas = ["lowvram",str(gpuchoiceidx)] if lowvram_var.get() == 1 else ["normal",str(gpuchoiceidx)]
-            if mmq_var.get()==1:
-                args.usecublas.append("mmq")
-        if gpulayers_var.get():
-            args.gpulayers = int(gpulayers_var.get())
-        if runopts_var.get()=="Use No BLAS":
-            args.noblas = True
-        if runopts_var.get()=="NoAVX2 Mode (Old CPU)":
-            args.noavx2 = True
-        if runopts_var.get()=="Failsafe Mode (Old CPU)":
-            args.noavx2 = True
-            args.noblas = True
-            args.nommap = True
-
-        args.blasthreads = None if blas_threads_var.get()=="" else int(blas_threads_var.get())
-
-        args.blasbatchsize = int(blasbatchsize_values[int(blas_size_var.get())])
-        args.forceversion = 0 if version_var.get()=="" else int(version_var.get())
-
-        args.contextsize = int(contextsize_text[context_var.get()])
-
-        if customrope_var.get()==1:
-            args.ropeconfig = [float(customrope_scale.get()),float(customrope_base.get())]
-
-        args.model_param = None if model_var.get() == "" else model_var.get()
-        args.lora = None if lora_var.get() == "" else ([lora_var.get()] if lora_base_var.get()=="" else [lora_var.get(), lora_base_var.get()])
-
-        args.port_param = defaultport if port_var.get()=="" else int(port_var.get())
-        args.host = host_var.get()
-        args.multiuser = multiuser_var.get() == 1
-
-        if horde_apikey_var.get()=="" or horde_workername_var.get()=="":
-            args.hordeconfig = None if usehorde_var.get() == 0 else [horde_name_var.get(), horde_gen_var.get(), horde_context_var.get()]
-        else:
-            args.hordeconfig = None if usehorde_var.get() == 0 else [horde_name_var.get(), horde_gen_var.get(), horde_context_var.get(), horde_apikey_var.get(), horde_workername_var.get()]
-
-    def import_vars(dict):
-        if "threads" in dict:
-            threads_var.set(dict["threads"])
-        usemlock.set(1 if "usemlock" in dict and dict["usemlock"] else 0)
-        if "debugmode" in dict:
-            debugmode.set(dict["debugmode"])
-        launchbrowser.set(1 if "launch" in dict and dict["launch"] else 0)
-        highpriority.set(1 if "highpriority" in dict and dict["highpriority"] else 0)
-        disablemmap.set(1 if "nommap" in dict and dict["nommap"] else 0)
-        smartcontext.set(1 if "smartcontext" in dict and dict["smartcontext"] else 0)
-        keepforeground.set(1 if "foreground" in dict and dict["foreground"] else 0)
-        if "useclblast" in dict and dict["useclblast"]:
-            if clblast_option is not None:
-                runopts_var.set(clblast_option)
-                gpu_choice_var.set(str(["0 0", "1 0", "0 1", "1 1"].index(str(dict["useclblast"][0]) + " " + str(dict["useclblast"][1])) + 1))
-        elif "usecublas" in dict and dict["usecublas"]:
-            if cublas_option is not None or hipblas_option is not None:
-                if cublas_option:
-                    runopts_var.set(cublas_option)
-                elif hipblas_option:
-                    runopts_var.set(cublas_option)
-                lowvram_var.set(1 if "lowvram" in dict["usecublas"] else 0)
-                mmq_var.set(1 if "mmq" in dict["usecublas"] else 0)
-                gpu_choice_var.set("All")
-                for g in range(4):
-                    if str(g) in dict["usecublas"]:
-                        gpu_choice_var.set(str(g+1))
-                        break
-        elif  "noavx2" in dict and "noblas" in dict and dict["noblas"] and dict["noavx2"]:
-            if failsafe_option is not None:
-                runopts_var.set(failsafe_option)
-        elif "noavx2" in dict and dict["noavx2"]:
-            if noavx2_option is not None:
-                runopts_var.set(noavx2_option)
-        elif "noblas" in dict and dict["noblas"]:
-            if default_option is not None:
-                runopts_var.set(default_option)
-        elif openblas_option is not None:
-                runopts_var.set(openblas_option)
-        if "gpulayers" in dict and dict["gpulayers"]:
-            gpulayers_var.set(dict["gpulayers"])
-        if "blasthreads" in dict and dict["blasthreads"]:
-            blas_threads_var.set(str(dict["blasthreads"]))
-        else:
-            blas_threads_var.set("")
-        if "contextsize" in dict and dict["contextsize"]:
-            context_var.set(contextsize_text.index(str(dict["contextsize"])))
-        if "ropeconfig" in dict and dict["ropeconfig"] and len(dict["ropeconfig"])>1:
-            if dict["ropeconfig"][0]>0:
-                customrope_var.set(1)
-                customrope_scale.set(str(dict["ropeconfig"][0]))
-                customrope_base.set(str(dict["ropeconfig"][1]))
-            else:
-                customrope_var.set(0)
-
-        if "blasbatchsize" in dict and dict["blasbatchsize"]:
-            blas_size_var.set(blasbatchsize_values.index(str(dict["blasbatchsize"])))
-        if "forceversion" in dict and dict["forceversion"]:
-            version_var.set(str(dict["forceversion"]))
-
-        if "model_param" in dict and dict["model_param"]:
-            model_var.set(dict["model_param"])
-
-        if "lora" in dict and dict["lora"]:
-            if len(dict["lora"]) > 1:
-                lora_var.set(dict["lora"][0])
-                lora_base_var.set(dict["lora"][1])
-            else:
-                lora_var.set(dict["lora"][0])
-
-        if "port_param" in dict and dict["port_param"]:
-            port_var.set(dict["port_param"])
-
-        if "host" in dict and dict["host"]:
-            host_var.set(dict["host"])
-
-        multiuser_var.set(1 if "multiuser" in dict and dict["multiuser"] else 0)
-
-        if "hordeconfig" in dict and dict["hordeconfig"] and len(dict["hordeconfig"]) > 1:
-            horde_name_var.set(dict["hordeconfig"][0])
-            horde_gen_var.set(dict["hordeconfig"][1])
-            horde_context_var.set(dict["hordeconfig"][2])
-            if len(dict["hordeconfig"]) > 4:
-                horde_apikey_var.set(dict["hordeconfig"][3])
-                horde_workername_var.set(dict["hordeconfig"][4])
-                usehorde_var.set("1")
-
-    def save_config():
-        file_type = [("KoboldCpp Settings", "*.kcpps")]
-        filename = asksaveasfile(filetypes=file_type, defaultextension=file_type)
-        if filename == None: return
-        export_vars()
-        file = open(str(filename.name), 'a')
-        file.write(json.dumps(args.__dict__))
-        file.close()
-        pass
-
-    def load_config():
-        file_type = [("KoboldCpp Settings", "*.kcpps")]
-        filename = askopenfilename(filetypes=file_type, defaultextension=file_type)
-        if not filename or filename=="":
-            return
-        with open(filename, 'r') as f:
-            dict = json.load(f)
-            import_vars(dict)
-        pass
-
-    def display_help():
-        try:
-            import webbrowser as wb
-            wb.open("https://github.com/LostRuins/koboldcpp/wiki")
-        except:
-            print("Cannot launch help in browser.")
-    def display_updates():
-        try:
-            import webbrowser as wb
-            wb.open("https://github.com/LostRuins/koboldcpp/releases/latest")
-        except:
-            print("Cannot launch updates in browser.")
-
-    ctk.CTkButton(tabs , text = "Launch", fg_color="#2f8d3c", hover_color="#2faa3c", command = guilaunch, width=80, height = 35 ).grid(row=1,column=1, stick="se", padx= 25, pady=5)
-
-    ctk.CTkButton(tabs , text = "Update", fg_color="#9900cc", hover_color="#aa11dd", command = display_updates, width=90, height = 35 ).grid(row=1,column=0, stick="sw", padx= 5, pady=5)
-    ctk.CTkButton(tabs , text = "Save", fg_color="#084a66", hover_color="#085a88", command = save_config, width=60, height = 35 ).grid(row=1,column=1, stick="sw", padx= 5, pady=5)
-    ctk.CTkButton(tabs , text = "Load", fg_color="#084a66", hover_color="#085a88", command = load_config, width=60, height = 35 ).grid(row=1,column=1, stick="sw", padx= 70, pady=5)
-    ctk.CTkButton(tabs , text = "Help", fg_color="#992222", hover_color="#bb3333", command = display_help, width=60, height = 35 ).grid(row=1,column=1, stick="sw", padx= 135, pady=5)
-
-    # runs main loop until closed or launch clicked
-    root.mainloop()
-
-    if nextstate==0:
-        print("Exiting by user request.")
-        time.sleep(3)
-        sys.exit()
-    else:
-        # processing vars
-        export_vars()
-
-        if not args.model_param:
-            print("\nNo ggml model file was selected. Exiting.")
-            time.sleep(3)
-            sys.exit(2)
-
-def show_gui_msgbox(title,message):
-    print(title + ": " + message)
-    try:
-        from tkinter import messagebox
-        import tkinter as tk
-        root = tk.Tk()
-        root.attributes("-alpha", 0)
-        messagebox.showerror(title=title, message=message)
-        root.destroy()
-    except Exception as ex2:
-        pass
-
-#A very simple and stripped down embedded horde worker with no dependencies
-def run_horde_worker(args, api_key, worker_name):
-    import urllib.request
-    from datetime import datetime
-    global friendlymodelname, maxhordectx, maxhordelen, exitcounter, modelbusy, session_starttime
-    epurl = f"http://localhost:{args.port}"
-    if args.host!="":
-        epurl = f"http://{args.host}:{args.port}"
-
-    def print_with_time(txt):
-        print(f"{datetime.now().strftime('[%H:%M:%S]')} " + txt)
-
-    def submit_completed_generation(url, jobid, sessionstart, submit_dict):
-        global exitcounter, session_kudos_earned, session_jobs
-        reply = make_url_request(url, submit_dict)
-        if not reply:
-            exitcounter += 1
-            print_with_time(f"Error, Job submit failed.")
-        else:
-            reward = reply["reward"]
-            session_kudos_earned += reward
-            session_jobs += 1
-            curtime = datetime.now()
-            elapsedtime=curtime-sessionstart
-            hrs = elapsedtime.seconds // 3600
-            mins = elapsedtime.seconds // 60 % 60
-            secs = elapsedtime.seconds % 60
-            elapsedtimestr = f"{hrs:03d}h:{mins:02d}m:{secs:02d}s"
-            earnrate = session_kudos_earned/(elapsedtime.seconds/3600)
-            print_with_time(f'Submitted {jobid} and earned {reward:.0f} kudos\n[Total:{session_kudos_earned:.0f} kudos, Time:{elapsedtimestr}, Jobs:{session_jobs}, EarnRate:{earnrate:.0f} kudos/hr]')
-
-    def make_url_request(url, data, method='POST'):
-        try:
-            request = None
-            headers = {"apikey": api_key,'User-Agent':'KoboldCppEmbeddedWorkerV2','Client-Agent':'KoboldCppEmbedWorker:2'}
-            if method=='POST':
-                json_payload = json.dumps(data).encode('utf-8')
-                request = urllib.request.Request(url, data=json_payload, headers=headers, method=method)
-                request.add_header('Content-Type', 'application/json')
-            else:
-                request = urllib.request.Request(url, headers=headers, method=method)
-            response_data = ""
-            with urllib.request.urlopen(request) as response:
-                response_data = response.read().decode('utf-8')
-                json_response = json.loads(response_data)
-                return json_response
-        except urllib.error.HTTPError as e:
-            try:
-                errmsg = e.read().decode('utf-8')
-                print_with_time(f"Error: {e} - {errmsg}, Make sure your Horde API key and worker name is valid.")
-            except Exception as e:
-                print_with_time(f"Error: {e}, Make sure your Horde API key and worker name is valid.")
-            return None
-        except Exception as e:
-            print_with_time(f"Error: {e} - {response_data}, Make sure your Horde API key and worker name is valid.")
-            return None
-
-    current_id = None
-    current_payload = None
-    current_generation = None
-    session_starttime = datetime.now()
-    sleepy_counter = 0 #if this exceeds a value, worker becomes sleepy (slower)
-    print(f"===\nEmbedded Horde Worker '{worker_name}' Starting...\n(To use your own KAI Bridge/Scribe worker instead, don't set your API key)")
-    BRIDGE_AGENT = f"KoboldCppEmbedWorker:2:https://github.com/LostRuins/koboldcpp"
-    cluster = "https://horde.koboldai.net"
-    while exitcounter < 10:
-        time.sleep(3)
-        readygo = make_url_request(f'{epurl}/api/v1/info/version', None,'GET')
-        if readygo:
-            print_with_time(f"Embedded Horde Worker '{worker_name}' is started.")
-            break
-
-    while exitcounter < 10:
-        currentjob_attempts = 0
-        current_generation = None
-
-        #first, make sure we are not generating
-        if modelbusy.locked():
-            time.sleep(0.2)
-            continue
-
-        #pop new request
-        gen_dict = {
-            "name": worker_name,
-            "models": [friendlymodelname],
-            "max_length": maxhordelen,
-            "max_context_length": maxhordectx,
-            "priority_usernames": [],
-            "softprompts": [],
-            "bridge_agent": BRIDGE_AGENT,
-        }
-        pop = make_url_request(f'{cluster}/api/v2/generate/text/pop',gen_dict)
-        if not pop:
-            exitcounter += 1
-            print_with_time(f"Failed to fetch job from {cluster}. Waiting 5 seconds...")
-            time.sleep(5)
-            continue
-        if not pop["id"]:
-            slp = (1 if sleepy_counter<10 else (2 if sleepy_counter<25 else 3))
-            time.sleep(slp)
-            sleepy_counter += 1
-            if sleepy_counter==20:
-                print_with_time(f"No recent jobs, entering low power mode...")
-            continue
-
-        sleepy_counter = 0
-        current_id = pop['id']
-        current_payload = pop['payload']
-        print(f"") #empty newline
-        print_with_time(f"Job received from {cluster} for {current_payload.get('max_length',80)} tokens and {current_payload.get('max_context_length',1024)} max context. Starting generation...")
-
-        #do gen
-        while exitcounter < 10:
-            if not modelbusy.locked():
-                current_generation = make_url_request(f'{epurl}/api/v1/generate', current_payload)
-                if current_generation:
-                    break
-                else:
-                    currentjob_attempts += 1
-                    if currentjob_attempts>5:
-                        break
-            print_with_time(f"Server Busy - Not ready to generate...")
-            time.sleep(5)
-
-        #submit reply
-        print(f"") #empty newline
-        if current_generation:
-            submit_dict = {
-                "id": current_id,
-                "generation": current_generation["results"][0]["text"],
-                "state": "ok"
-            }
-            submiturl = cluster + '/api/v2/generate/text/submit'
-            submit_thread = threading.Thread(target=submit_completed_generation, args=(submiturl, current_id, session_starttime, submit_dict))
-            submit_thread.start() #submit job in new thread so nothing is waiting
-        else:
-            print_with_time(f"Error, Abandoned current job due to errors. Getting new job.")
-        current_id = None
-        current_payload = None
-        time.sleep(0.1)
-
-    if exitcounter<100:
-        print_with_time(f"Horde Worker Shutdown - Too many errors.")
-        time.sleep(3)
-    else:
-        print_with_time(f"Horde Worker Shutdown - Server Closing.")
-        time.sleep(3)
-    sys.exit(2)
-
-def unload_libs():
-    global handle
-    import platform
-    OS = platform.system()
-    dll_close = None
-    if OS == "Windows":  # pragma: Windows
-        from ctypes import wintypes
-        dll_close = ctypes.windll.kernel32.FreeLibrary
-        dll_close.argtypes = [wintypes.HMODULE]
-        dll_close.restype = ctypes.c_int
-    elif OS == "Darwin":
-        try:
-            try:  # macOS 11 (Big Sur). Possibly also later macOS 10s.
-                stdlib = ctypes.CDLL("libc.dylib")
-            except OSError:
-                stdlib = ctypes.CDLL("libSystem")
-        except OSError:
-            # Older macOSs. Not only is the name inconsistent but it's
-            # not even in PATH.
-            stdlib = ctypes.CDLL("/usr/lib/system/libsystem_c.dylib")
-        dll_close = stdlib.dlclose
-        dll_close.argtypes = [ctypes.c_void_p]
-        dll_close.restype = ctypes.c_int
-    elif OS == "Linux":
-        try:
-            stdlib = ctypes.CDLL("")
-        except OSError:
-            stdlib = ctypes.CDLL("libc.so") # Alpine Linux.
-        dll_close = stdlib.dlclose
-        dll_close.argtypes = [ctypes.c_void_p]
-        dll_close.restype = ctypes.c_int
-    elif sys.platform == "msys":
-        # msys can also use `ctypes.CDLL("kernel32.dll").FreeLibrary()`.
-        stdlib = ctypes.CDLL("msys-2.0.dll")
-        dll_close = stdlib.dlclose
-        dll_close.argtypes = [ctypes.c_void_p]
-        dll_close.restype = ctypes.c_int
-    elif sys.platform == "cygwin":
-        stdlib = ctypes.CDLL("cygwin1.dll")
-        dll_close = stdlib.dlclose
-        dll_close.argtypes = [ctypes.c_void_p]
-        dll_close.restype = ctypes.c_int
-    elif OS == "FreeBSD":
-        # FreeBSD uses `/usr/lib/libc.so.7` where `7` is another version number.
-        # It is not in PATH but using its name instead of its path is somehow the
-        # only way to open it. The name must include the .so.7 suffix.
-        stdlib = ctypes.CDLL("libc.so.7")
-        dll_close = stdlib.close
-
-    if handle and dll_close:
-        print("Unloading Libraries...")
-        dll_close(handle._handle)
-        del handle.load_model
-        del handle.generate
-        del handle.new_token
-        del handle.get_stream_count
-        del handle.has_finished
-        del handle.get_last_eval_time
-        del handle.get_last_process_time
-        del handle.get_last_token_count
-        del handle.get_last_stop_reason
-        del handle.abort_generate
-        del handle.token_count
-        del handle.get_pending_output
-        del handle
-        handle = None
-
-def loadconfigfile(filename):
-    print("Loading kcpps configuration file...")
-    with open(filename, 'r') as f:
-        config = json.load(f)
-        for key, value in config.items():
-            setattr(args, key, value)
-
-def sanitize_string(input_string):
-    # alphanumeric characters, dots, dashes, and underscores
-    import re
-    sanitized_string = re.sub( r'[^\w\d\.\-_]', '', input_string)
-    return sanitized_string
-
-def main(launch_args,start_server=True):
-    global args, friendlymodelname
-    args = launch_args
-    embedded_kailite = None
-    embedded_kcpp_docs = None
-    if args.config and len(args.config)==1:
-        if isinstance(args.config[0], str) and os.path.exists(args.config[0]):
-           loadconfigfile(args.config[0])
-        else:
-            print("Specified kcpp config file invalid or not found.")
-            time.sleep(3)
-            sys.exit(2)
-
-    #positional handling for kcpps files (drag and drop)
-    if args.model_param and args.model_param!="" and args.model_param.lower().endswith('.kcpps'):
-        loadconfigfile(args.model_param)
-
-    if not args.model_param:
-        args.model_param = args.model
-
-    if not args.model_param:
-        #give them a chance to pick a file
-        print("For command line arguments, please refer to --help")
-        print("***")
-        try:
-            show_new_gui()
-        except Exception as ex:
-            ermsg = "Reason: " + str(ex) + "\nFile selection GUI unsupported.\ncustomtkinter python module required!\nPlease check command line: script.py --help"
-            show_gui_msgbox("Warning, GUI failed to start",ermsg)
-            time.sleep(3)
-            sys.exit(2)
-
-    # sanitize and replace the default vanity name. remember me....
-    if args.model_param!="":
-        newmdldisplayname = os.path.basename(args.model_param)
-        newmdldisplayname = os.path.splitext(newmdldisplayname)[0]
-        friendlymodelname = "koboldcpp/" + sanitize_string(newmdldisplayname)
-
-    if args.hordeconfig and args.hordeconfig[0]!="":
-        global maxhordelen, maxhordectx, showdebug
-        friendlymodelname = args.hordeconfig[0]
-        if args.debugmode == 1:
-            friendlymodelname = "debug-" + friendlymodelname
-        if not friendlymodelname.startswith("koboldcpp/"):
-            friendlymodelname = "koboldcpp/" + friendlymodelname
-        if len(args.hordeconfig) > 1:
-            maxhordelen = int(args.hordeconfig[1])
-        if len(args.hordeconfig) > 2:
-            maxhordectx = int(args.hordeconfig[2])
-        if args.debugmode == 0:
-            args.debugmode = -1
-
-    if args.debugmode != 1:
-        showdebug = False
-
-    if args.highpriority:
-        print("Setting process to Higher Priority - Use Caution")
-        try:
-            import psutil
-            os_used = sys.platform
-            process = psutil.Process(os.getpid())  # Set high priority for the python script for the CPU
-            oldprio = process.nice()
-            if os_used == "win32":  # Windows (either 32-bit or 64-bit)
-                process.nice(psutil.REALTIME_PRIORITY_CLASS)
-                print("High Priority for Windows Set: " + str(oldprio) + " to " + str(process.nice()))
-            elif os_used == "linux":  # linux
-                process.nice(psutil.IOPRIO_CLASS_RT)
-                print("High Priority for Linux Set: " + str(oldprio) + " to " + str(process.nice()))
-            else:  # MAC OS X or other
-                process.nice(-18)
-                print("High Priority for Other OS Set :" + str(oldprio) + " to " + str(process.nice()))
-        except Exception as ex:
-             print("Error, Could not change process priority: " + str(ex))
-
-    if args.contextsize:
-        global maxctx
-        maxctx = args.contextsize
-
-    init_library() # Note: if blas does not exist and is enabled, program will crash.
-    print("==========")
-    time.sleep(1)
-    if not os.path.exists(args.model_param):
-        print(f"Cannot find model file: {args.model_param}")
-        time.sleep(3)
-        sys.exit(2)
-
-    if args.lora and args.lora[0]!="":
-        if not os.path.exists(args.lora[0]):
-            print(f"Cannot find lora file: {args.lora[0]}")
-            time.sleep(3)
-            sys.exit(2)
-        else:
-            args.lora[0] = os.path.abspath(args.lora[0])
-            if len(args.lora) > 1:
-                if not os.path.exists(args.lora[1]):
-                    print(f"Cannot find lora base: {args.lora[1]}")
-                    time.sleep(3)
-                    sys.exit(2)
-                else:
-                    args.lora[1] = os.path.abspath(args.lora[1])
-
-    if not args.blasthreads or args.blasthreads <= 0:
-        args.blasthreads = args.threads
-
-    modelname = os.path.abspath(args.model_param)
-    print(args)
-    print(f"==========\nLoading model: {modelname} \n[Threads: {args.threads}, BlasThreads: {args.blasthreads}, SmartContext: {args.smartcontext}]")
-    loadok = load_model(modelname)
-    print("Load Model OK: " + str(loadok))
-
-    if not loadok:
-        print("Could not load model: " + modelname)
-        time.sleep(3)
-        sys.exit(3)
-    try:
-        basepath = os.path.abspath(os.path.dirname(__file__))
-        with open(os.path.join(basepath, "klite.embd"), mode='rb') as f:
-            embedded_kailite = f.read()
-            print("Embedded Kobold Lite loaded.")
-    except:
-        print("Could not find Kobold Lite. Embedded Kobold Lite will not be available.")
-
-    try:
-        basepath = os.path.abspath(os.path.dirname(__file__))
-        with open(os.path.join(basepath, "kcpp_docs.embd"), mode='rb') as f:
-            embedded_kcpp_docs = f.read()
-    except:
-        print("Could not find Embedded KoboldCpp API docs.")
-
-    if args.port_param!=defaultport:
-        args.port = args.port_param
-    print(f"Starting Kobold HTTP Server on port {args.port}")
-    epurl = ""
-    if args.host=="":
-        epurl = f"http://localhost:{args.port}"
-    else:
-        epurl = f"http://{args.host}:{args.port}"
-
-    if args.launch:
-        try:
-            import webbrowser as wb
-            wb.open(epurl)
-        except:
-            print("--launch was set, but could not launch web browser automatically.")
-
-    if args.hordeconfig and len(args.hordeconfig)>4:
-        horde_thread = threading.Thread(target=run_horde_worker,args=(args,args.hordeconfig[3],args.hordeconfig[4]))
-        horde_thread.daemon = True
-        horde_thread.start()
-
-    #if post-ready script specified, execute it
-    if args.onready:
-        def onready_subprocess():
-            import subprocess
-            print("Starting Post-Load subprocess...")
-            subprocess.run(args.onready[0], shell=True)
-        timer_thread = threading.Timer(1, onready_subprocess) #1 second delay
-        timer_thread.start()
-
-    if start_server:
-        print(f"Please connect to custom endpoint at {epurl}")
-        asyncio.run(RunServerMultiThreaded(args.host, args.port, embedded_kailite, embedded_kcpp_docs))
-    else:
-        print(f"Server was not started, main function complete. Idling.")
-
-if __name__ == '__main__':
-    print("***\nWelcome to KoboldCpp - Version " + KcppVersion) # just update version manually
-    # print("Python version: " + sys.version)
-    parser = argparse.ArgumentParser(description='KoboldCpp Server')
-    modelgroup = parser.add_mutually_exclusive_group() #we want to be backwards compatible with the unnamed positional args
-    modelgroup.add_argument("--model", help="Model file to load", nargs="?")
-    modelgroup.add_argument("model_param", help="Model file to load (positional)", nargs="?")
-    portgroup = parser.add_mutually_exclusive_group() #we want to be backwards compatible with the unnamed positional args
-    portgroup.add_argument("--port", help="Port to listen on", default=defaultport, type=int, action='store')
-    portgroup.add_argument("port_param", help="Port to listen on (positional)", default=defaultport, nargs="?", type=int, action='store')
-    parser.add_argument("--host", help="Host IP to listen on. If empty, all routable interfaces are accepted.", default="")
-    parser.add_argument("--launch", help="Launches a web browser when load is completed.", action='store_true')
-    parser.add_argument("--lora", help="LLAMA models only, applies a lora file on top of model. Experimental.", metavar=('[lora_filename]', '[lora_base]'), nargs='+')
-    parser.add_argument("--config", help="Load settings from a .kcpps file. Other arguments will be ignored", type=str, nargs=1)
-    physical_core_limit = 1
-    if os.cpu_count()!=None and os.cpu_count()>1:
-        physical_core_limit = int(os.cpu_count()/2)
-    default_threads = (physical_core_limit if physical_core_limit<=3 else max(3,physical_core_limit-1))
-    parser.add_argument("--threads", help="Use a custom number of threads if specified. Otherwise, uses an amount based on CPU cores", type=int, default=default_threads)
-    parser.add_argument("--blasthreads", help="Use a different number of threads during BLAS if specified. Otherwise, has the same value as --threads",metavar=('[threads]'), type=int, default=0)
-    parser.add_argument("--highpriority", help="Experimental flag. If set, increases the process CPU priority, potentially speeding up generation. Use caution.", action='store_true')
-    parser.add_argument("--contextsize", help="Controls the memory allocated for maximum context size, only change if you need more RAM for big contexts. (default 2048)", type=int,choices=[512,1024,2048,3072,4096,6144,8192,12288,16384,24576,32768,65536], default=2048)
-    parser.add_argument("--blasbatchsize", help="Sets the batch size used in BLAS processing (default 512). Setting it to -1 disables BLAS mode, but keeps other benefits like GPU offload.", type=int,choices=[-1,32,64,128,256,512,1024,2048], default=512)
-    parser.add_argument("--ropeconfig", help="If set, uses customized RoPE scaling from configured frequency scale and frequency base (e.g. --ropeconfig 0.25 10000). Otherwise, uses NTK-Aware scaling set automatically based on context size. For linear rope, simply set the freq-scale and ignore the freq-base",metavar=('[rope-freq-scale]', '[rope-freq-base]'), default=[0.0, 10000.0], type=float, nargs='+')
-    parser.add_argument("--smartcontext", help="Reserving a portion of context to try processing less frequently.", action='store_true')
-    parser.add_argument("--bantokens", help="You can manually specify a list of token SUBSTRINGS that the AI cannot use. This bans ALL instances of that substring.", metavar=('[token_substrings]'), nargs='+')
-    parser.add_argument("--forceversion", help="If the model file format detection fails (e.g. rogue modified model) you can set this to override the detected format (enter desired version, e.g. 401 for GPTNeoX-Type2).",metavar=('[version]'), type=int, default=0)
-    parser.add_argument("--nommap", help="If set, do not use mmap to load newer models", action='store_true')
-    parser.add_argument("--usemlock", help="For Apple Systems. Force system to keep model in RAM rather than swapping or compressing", action='store_true')
-    parser.add_argument("--noavx2", help="Do not use AVX2 instructions, a slower compatibility mode for older devices. Does not work with --clblast.", action='store_true')
-    parser.add_argument("--debugmode", help="Shows additional debug info in the terminal.", nargs='?', const=1, type=int, default=0)
-    parser.add_argument("--skiplauncher", help="Doesn't display or use the GUI launcher.", action='store_true')
-    parser.add_argument("--hordeconfig", help="Sets the display model name to something else, for easy use on AI Horde. Optional additional parameters set the horde max genlength, max ctxlen, API key and worker name.",metavar=('[hordemodelname]', '[hordegenlength] [hordemaxctx] [hordeapikey] [hordeworkername]'), nargs='+')
-    compatgroup = parser.add_mutually_exclusive_group()
-    compatgroup.add_argument("--noblas", help="Do not use OpenBLAS for accelerated prompt ingestion", action='store_true')
-    compatgroup.add_argument("--useclblast", help="Use CLBlast for GPU Acceleration. Must specify exactly 2 arguments, platform ID and device ID (e.g. --useclblast 1 0).", type=int, choices=range(0,9), nargs=2)
-    compatgroup.add_argument("--usecublas", help="Use CuBLAS for GPU Acceleration. Requires CUDA. Select lowvram to not allocate VRAM scratch buffer. Enter a number afterwards to select and use 1 GPU. Leaving no number will use all GPUs. For hipBLAS binaries, please check YellowRoseCx rocm fork.", nargs='*',metavar=('[lowvram|normal] [main GPU ID] [mmq]'), choices=['normal', 'lowvram', '0', '1', '2', '3', 'mmq'])
-    parser.add_argument("--gpulayers", help="Set number of layers to offload to GPU when using GPU. Requires GPU.",metavar=('[GPU layers]'), type=int, default=0)
-    parser.add_argument("--tensor_split", help="For CUDA with ALL GPU set only, ratio to split tensors across multiple GPUs, space-separated list of proportions, e.g. 7 3", metavar=('[Ratios]'), type=float, nargs='+')
-    parser.add_argument("--onready", help="An optional shell command to execute after the model has been loaded.", type=str, default="",nargs=1)
-    parser.add_argument("--multiuser", help="Runs in multiuser mode, which queues incoming requests instead of blocking them.", action='store_true')
-    parser.add_argument("--foreground", help="Windows only. Sends the terminal to the foreground every time a new prompt is generated. This helps avoid some idle slowdown issues.", action='store_true')
-
-    main(parser.parse_args(),start_server=True)
diff --git a/spaces/Illumotion/Koboldcpp/otherarch/rwkv_v2.h b/spaces/Illumotion/Koboldcpp/otherarch/rwkv_v2.h
deleted file mode 100644
index ea8388f2444c8edd43d39649166973fb612f1761..0000000000000000000000000000000000000000
--- a/spaces/Illumotion/Koboldcpp/otherarch/rwkv_v2.h
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef RWKV_H2
-#define RWKV_H2
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-#ifdef RWKV_SHARED2
-#    if defined(_WIN32) && !defined(__MINGW32__)
-#        ifdef RWKV_BUILD
-#            define RWKV_V2_API __declspec(dllexport)
-#        else
-#            define RWKV_V2_API __declspec(dllimport)
-#        endif
-#    else
-#        define RWKV_V2_API __attribute__ ((visibility ("default")))
-#    endif
-#else
-#    define RWKV_V2_API
-#endif
-
-// 'ggmf' in hex.
-#define RWKV_V2_FILE_MAGIC 0x67676d66
-#define RWKV_V2_FILE_VERSION 100
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-    struct rwkv_v2_context;
-
-    // Loads the model from a file and prepares it for inference.
-    // Returns NULL on any error. Error messages would be printed to stderr.
-    // - model_file_path: path to model file in ggml format.
-    // - n_threads: count of threads to use, must be positive.
-    RWKV_V2_API struct rwkv_v2_context * rwkv_v2_init_from_file(const char * model_file_path, uint32_t n_threads);
-
-    // Evaluates the model for a single token.
-    // Returns false on any error. Error messages would be printed to stderr.
-    // - token: next token index, in range 0 <= token < n_vocab.
-    // - state_in: FP32 buffer of size rwkv_v2_get_state_buffer_element_count; or NULL, if this is a first pass.
-    // - state_out: FP32 buffer of size rwkv_v2_get_state_buffer_element_count. This buffer will be written to.
-    // - logits_out: FP32 buffer of size rwkv_v2_get_logits_buffer_element_count. This buffer will be written to.
-    RWKV_V2_API bool rwkv_v2_eval(struct rwkv_v2_context * ctx, int32_t token, float * state_in, float * state_out, float * logits_out);
-
-    // Returns count of FP32 elements in state buffer.
-    RWKV_V2_API uint32_t rwkv_v2_get_state_buffer_element_count(struct rwkv_v2_context * ctx);
-
-    // Returns count of FP32 elements in logits buffer.
-    RWKV_V2_API uint32_t rwkv_v2_get_logits_buffer_element_count(struct rwkv_v2_context * ctx);
-
-    // Frees all allocated memory and the context.
-    RWKV_V2_API void rwkv_v2_free(struct rwkv_v2_context * ctx);
-
-    // Quantizes FP32 or FP16 model to one of quantized formats.
-    // Returns false on any error. Error messages would be printed to stderr.
-    // - model_file_path_in: path to model file in ggml format, must be either FP32 or FP16.
-    // - model_file_path_out: quantized model will be written here.
-    // - format_name: must be one of available format names below.
-    // Available format names:
-    // - Q4_0
-    // - Q4_1
-    // - Q4_2
-    // - Q5_0
-    // - Q5_1
-    // - Q8_0
-    RWKV_V2_API bool rwkv_v2_quantize_model_file(const char * model_file_path_in, const char * model_file_path_out, const char * format_name);
-
-    // Returns system information string.
-    RWKV_V2_API const char * rwkv_v2_get_system_info_string(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
\ No newline at end of file
diff --git a/spaces/Illumotion/Koboldcpp/scripts/run-all-perf.sh b/spaces/Illumotion/Koboldcpp/scripts/run-all-perf.sh
deleted file mode 100644
index 6384e364d558439ad5a7e46ba2f0d7188615c66a..0000000000000000000000000000000000000000
--- a/spaces/Illumotion/Koboldcpp/scripts/run-all-perf.sh
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/bin/bash
-
-qnt=(f16 q8_0 q6_k q5_k q5_1 q5_0 q4_k q4_1 q4_0 q3_k q2_k)
-args="-ngl 999 -n 64 -p 512"
-
-if [ -z "$1" ]; then
-    echo "usage: $0 <model> [qnt] [args]"
-    echo "default: $0 <model> \"${qnt[@]}\" \"${args}\""
-    exit 1
-fi
-
-if [ ! -z "$2" ]; then
-    qnt=($2)
-fi
-
-if [ ! -z "$3" ]; then
-    args="$3"
-fi
-
-model="$1"
-out="../tmp/results-${model}"
-
-set -o pipefail
-set -e
-
-mkdir -p ${out}
-
-mstr=""
-
-for q in ${qnt[@]}; do
-    mstr="${mstr} -m ../models/${model}/ggml-model-${q}.gguf"
-done
-
-./bin/llama-bench ${mstr} ${args} 2> /dev/null
diff --git a/spaces/InpaintAI/Inpaint-Anything/third_party/lama/saicinpainting/training/losses/perceptual.py b/spaces/InpaintAI/Inpaint-Anything/third_party/lama/saicinpainting/training/losses/perceptual.py
deleted file mode 100644
index 8c055c2b327ce7943682af5c5f9394b9fcbec506..0000000000000000000000000000000000000000
--- a/spaces/InpaintAI/Inpaint-Anything/third_party/lama/saicinpainting/training/losses/perceptual.py
+++ /dev/null
@@ -1,113 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision
-
-from models.ade20k import ModelBuilder
-from saicinpainting.utils import check_and_warn_input_range
-
-
-IMAGENET_MEAN = torch.FloatTensor([0.485, 0.456, 0.406])[None, :, None, None]
-IMAGENET_STD = torch.FloatTensor([0.229, 0.224, 0.225])[None, :, None, None]
-
-
-class PerceptualLoss(nn.Module):
-    def __init__(self, normalize_inputs=True):
-        super(PerceptualLoss, self).__init__()
-
-        self.normalize_inputs = normalize_inputs
-        self.mean_ = IMAGENET_MEAN
-        self.std_ = IMAGENET_STD
-
-        vgg = torchvision.models.vgg19(pretrained=True).features
-        vgg_avg_pooling = []
-
-        for weights in vgg.parameters():
-            weights.requires_grad = False
-
-        for module in vgg.modules():
-            if module.__class__.__name__ == 'Sequential':
-                continue
-            elif module.__class__.__name__ == 'MaxPool2d':
-                vgg_avg_pooling.append(nn.AvgPool2d(kernel_size=2, stride=2, padding=0))
-            else:
-                vgg_avg_pooling.append(module)
-
-        self.vgg = nn.Sequential(*vgg_avg_pooling)
-
-    def do_normalize_inputs(self, x):
-        return (x - self.mean_.to(x.device)) / self.std_.to(x.device)
-
-    def partial_losses(self, input, target, mask=None):
-        check_and_warn_input_range(target, 0, 1, 'PerceptualLoss target in partial_losses')
-
-        # we expect input and target to be in [0, 1] range
-        losses = []
-
-        if self.normalize_inputs:
-            features_input = self.do_normalize_inputs(input)
-            features_target = self.do_normalize_inputs(target)
-        else:
-            features_input = input
-            features_target = target
-
-        for layer in self.vgg[:30]:
-
-            features_input = layer(features_input)
-            features_target = layer(features_target)
-
-            if layer.__class__.__name__ == 'ReLU':
-                loss = F.mse_loss(features_input, features_target, reduction='none')
-
-                if mask is not None:
-                    cur_mask = F.interpolate(mask, size=features_input.shape[-2:],
-                                             mode='bilinear', align_corners=False)
-                    loss = loss * (1 - cur_mask)
-
-                loss = loss.mean(dim=tuple(range(1, len(loss.shape))))
-                losses.append(loss)
-
-        return losses
-
-    def forward(self, input, target, mask=None):
-        losses = self.partial_losses(input, target, mask=mask)
-        return torch.stack(losses).sum(dim=0)
-
-    def get_global_features(self, input):
-        check_and_warn_input_range(input, 0, 1, 'PerceptualLoss input in get_global_features')
-
-        if self.normalize_inputs:
-            features_input = self.do_normalize_inputs(input)
-        else:
-            features_input = input
-
-        features_input = self.vgg(features_input)
-        return features_input
-
-
-class ResNetPL(nn.Module):
-    def __init__(self, weight=1,
-                 weights_path=None, arch_encoder='resnet50dilated', segmentation=True):
-        super().__init__()
-        self.impl = ModelBuilder.get_encoder(weights_path=weights_path,
-                                             arch_encoder=arch_encoder,
-                                             arch_decoder='ppm_deepsup',
-                                             fc_dim=2048,
-                                             segmentation=segmentation)
-        self.impl.eval()
-        for w in self.impl.parameters():
-            w.requires_grad_(False)
-
-        self.weight = weight
-
-    def forward(self, pred, target):
-        pred = (pred - IMAGENET_MEAN.to(pred)) / IMAGENET_STD.to(pred)
-        target = (target - IMAGENET_MEAN.to(target)) / IMAGENET_STD.to(target)
-
-        pred_feats = self.impl(pred, return_feature_maps=True)
-        target_feats = self.impl(target, return_feature_maps=True)
-
-        result = torch.stack([F.mse_loss(cur_pred, cur_target)
-                              for cur_pred, cur_target
-                              in zip(pred_feats, target_feats)]).sum() * self.weight
-        return result
diff --git a/spaces/Ishaan1510/deep_learn/README.md b/spaces/Ishaan1510/deep_learn/README.md
deleted file mode 100644
index 8097bb17314d0b7755a8a0b80544c455ce737e48..0000000000000000000000000000000000000000
--- a/spaces/Ishaan1510/deep_learn/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Deep Learn
-emoji: 📉
-colorFrom: green
-colorTo: gray
-sdk: gradio
-sdk_version: 3.8.2
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Jamphus/G/app.py b/spaces/Jamphus/G/app.py
deleted file mode 100644
index 4287ca8617970fa8fc025b75cb319c7032706910..0000000000000000000000000000000000000000
--- a/spaces/Jamphus/G/app.py
+++ /dev/null
@@ -1 +0,0 @@
-#
\ No newline at end of file
diff --git a/spaces/Jasonyoyo/CodeFormer/CodeFormer/basicsr/utils/options.py b/spaces/Jasonyoyo/CodeFormer/CodeFormer/basicsr/utils/options.py
deleted file mode 100644
index db490e4aa52e26fde31959fd74c2cef3af2ecf76..0000000000000000000000000000000000000000
--- a/spaces/Jasonyoyo/CodeFormer/CodeFormer/basicsr/utils/options.py
+++ /dev/null
@@ -1,108 +0,0 @@
-import yaml
-import time
-from collections import OrderedDict
-from os import path as osp
-from basicsr.utils.misc import get_time_str
-
-def ordered_yaml():
-    """Support OrderedDict for yaml.
-
-    Returns:
-        yaml Loader and Dumper.
-    """
-    try:
-        from yaml import CDumper as Dumper
-        from yaml import CLoader as Loader
-    except ImportError:
-        from yaml import Dumper, Loader
-
-    _mapping_tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG
-
-    def dict_representer(dumper, data):
-        return dumper.represent_dict(data.items())
-
-    def dict_constructor(loader, node):
-        return OrderedDict(loader.construct_pairs(node))
-
-    Dumper.add_representer(OrderedDict, dict_representer)
-    Loader.add_constructor(_mapping_tag, dict_constructor)
-    return Loader, Dumper
-
-
-def parse(opt_path, root_path, is_train=True):
-    """Parse option file.
-
-    Args:
-        opt_path (str): Option file path.
-        is_train (str): Indicate whether in training or not. Default: True.
-
-    Returns:
-        (dict): Options.
-    """
-    with open(opt_path, mode='r') as f:
-        Loader, _ = ordered_yaml()
-        opt = yaml.load(f, Loader=Loader)
-
-    opt['is_train'] = is_train
-
-    # opt['name'] = f"{get_time_str()}_{opt['name']}"
-    if opt['path'].get('resume_state', None): # Shangchen added
-        resume_state_path = opt['path'].get('resume_state')
-        opt['name'] = resume_state_path.split("/")[-3]
-    else:
-        opt['name'] = f"{get_time_str()}_{opt['name']}"
-
-
-    # datasets
-    for phase, dataset in opt['datasets'].items():
-        # for several datasets, e.g., test_1, test_2
-        phase = phase.split('_')[0]
-        dataset['phase'] = phase
-        if 'scale' in opt:
-            dataset['scale'] = opt['scale']
-        if dataset.get('dataroot_gt') is not None:
-            dataset['dataroot_gt'] = osp.expanduser(dataset['dataroot_gt'])
-        if dataset.get('dataroot_lq') is not None:
-            dataset['dataroot_lq'] = osp.expanduser(dataset['dataroot_lq'])
-
-    # paths
-    for key, val in opt['path'].items():
-        if (val is not None) and ('resume_state' in key or 'pretrain_network' in key):
-            opt['path'][key] = osp.expanduser(val)
-
-    if is_train:
-        experiments_root = osp.join(root_path, 'experiments', opt['name'])
-        opt['path']['experiments_root'] = experiments_root
-        opt['path']['models'] = osp.join(experiments_root, 'models')
-        opt['path']['training_states'] = osp.join(experiments_root, 'training_states')
-        opt['path']['log'] = experiments_root
-        opt['path']['visualization'] = osp.join(experiments_root, 'visualization')
-
-    else:  # test
-        results_root = osp.join(root_path, 'results', opt['name'])
-        opt['path']['results_root'] = results_root
-        opt['path']['log'] = results_root
-        opt['path']['visualization'] = osp.join(results_root, 'visualization')
-
-    return opt
-
-
-def dict2str(opt, indent_level=1):
-    """dict to string for printing options.
-
-    Args:
-        opt (dict): Option dict.
-        indent_level (int): Indent level. Default: 1.
-
-    Return:
-        (str): Option string for printing.
-    """
-    msg = '\n'
-    for k, v in opt.items():
-        if isinstance(v, dict):
-            msg += ' ' * (indent_level * 2) + k + ':['
-            msg += dict2str(v, indent_level + 1)
-            msg += ' ' * (indent_level * 2) + ']\n'
-        else:
-            msg += ' ' * (indent_level * 2) + k + ': ' + str(v) + '\n'
-    return msg
diff --git a/spaces/JoeyFoursheds/ClonerHug/config.py b/spaces/JoeyFoursheds/ClonerHug/config.py
deleted file mode 100644
index e3da2f26fd10652a5747102da60357b9234dac2d..0000000000000000000000000000000000000000
--- a/spaces/JoeyFoursheds/ClonerHug/config.py
+++ /dev/null
@@ -1,79 +0,0 @@
-#Nvidia or Apple silicon
-device = "cuda:0"
-
-#For all nvida 10 series onwards, use half precision
-is_half = True
-
-# use all threads
-n_cpu = 0
-
-#Command-line Parameters
-import argparse
-
-parser = argparse.ArgumentParser()
-parser.add_argument("--port", type=int, default=7865, help="Listen port")
-parser.add_argument("--pycmd", type=str, default="python", help="Python command")
-parser.add_argument("--colab", action="store_true", help="Launch in colab")
-parser.add_argument(
-    "--noparallel", action="store_true", help="Disable parallel processing"
-)
-parser.add_argument(
-    "--noautoopen", action="store_true", help="Do not open in browser automatically"
-)
-cmd_opts, unknown = parser.parse_known_args()
-
-python_cmd = cmd_opts.pycmd
-listen_port = cmd_opts.port
-iscolab = cmd_opts.colab
-noparallel = cmd_opts.noparallel
-noautoopen = cmd_opts.noautoopen
-
-import sys
-import torch
-
-# has_mps is only available in nightly pytorch (for now) and MasOS 12.3+.
-# check `getattr` and try it for compatibility
-def has_mps() -> bool:
-    if sys.platform != "darwin":
-        return False
-    else:
-        if not getattr(torch, "has_mps", False):
-            return False
-        try:
-            torch.zeros(1).to(torch.device("mps"))
-            return True
-        except Exception:
-            return False
-
-
-if not torch.cuda.is_available():
-    if has_mps():
-        print("No Nvidia support, using MPS")
-        device = "mps"
-    else:
-        print("No Nvidia support, using CPU")
-        device = "cpu"
-        is_half = False
-
-if device not in ["cpu", "mps"]:
-    gpu_name = torch.cuda.get_device_name(int(device.split(":")[-1]))
-    if "16" in gpu_name or "MX" in gpu_name:
-        print("For 16 series graphics cards/MX series graphics cards, force single precision")
-        is_half = False
-
-from multiprocessing import cpu_count
-
-if n_cpu == 0:
-    n_cpu = cpu_count()
-if is_half:
-    # 6GB VRAM configuration
-    x_pad = 3
-    x_query = 10
-    x_center = 60
-    x_max = 65
-else:
-    # 5GB VRAM configuration
-    x_pad = 1
-    x_query = 6
-    x_center = 38
-    x_max = 41
diff --git a/spaces/Kangarroar/ApplioRVC-Inference/infer/lib/uvr5_pack/lib_v5/layers_33966KB.py b/spaces/Kangarroar/ApplioRVC-Inference/infer/lib/uvr5_pack/lib_v5/layers_33966KB.py
deleted file mode 100644
index 9b127bc6427f5c60c8cf85603a3d8a093c3501c4..0000000000000000000000000000000000000000
--- a/spaces/Kangarroar/ApplioRVC-Inference/infer/lib/uvr5_pack/lib_v5/layers_33966KB.py
+++ /dev/null
@@ -1,126 +0,0 @@
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from . import spec_utils
-
-
-class Conv2DBNActiv(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
-        super(Conv2DBNActiv, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Conv2d(
-                nin,
-                nout,
-                kernel_size=ksize,
-                stride=stride,
-                padding=pad,
-                dilation=dilation,
-                bias=False,
-            ),
-            nn.BatchNorm2d(nout),
-            activ(),
-        )
-
-    def __call__(self, x):
-        return self.conv(x)
-
-
-class SeperableConv2DBNActiv(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
-        super(SeperableConv2DBNActiv, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Conv2d(
-                nin,
-                nin,
-                kernel_size=ksize,
-                stride=stride,
-                padding=pad,
-                dilation=dilation,
-                groups=nin,
-                bias=False,
-            ),
-            nn.Conv2d(nin, nout, kernel_size=1, bias=False),
-            nn.BatchNorm2d(nout),
-            activ(),
-        )
-
-    def __call__(self, x):
-        return self.conv(x)
-
-
-class Encoder(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
-        super(Encoder, self).__init__()
-        self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
-        self.conv2 = Conv2DBNActiv(nout, nout, ksize, stride, pad, activ=activ)
-
-    def __call__(self, x):
-        skip = self.conv1(x)
-        h = self.conv2(skip)
-
-        return h, skip
-
-
-class Decoder(nn.Module):
-    def __init__(
-        self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
-    ):
-        super(Decoder, self).__init__()
-        self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
-        self.dropout = nn.Dropout2d(0.1) if dropout else None
-
-    def __call__(self, x, skip=None):
-        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
-        if skip is not None:
-            skip = spec_utils.crop_center(skip, x)
-            x = torch.cat([x, skip], dim=1)
-        h = self.conv(x)
-
-        if self.dropout is not None:
-            h = self.dropout(h)
-
-        return h
-
-
-class ASPPModule(nn.Module):
-    def __init__(self, nin, nout, dilations=(4, 8, 16, 32, 64), activ=nn.ReLU):
-        super(ASPPModule, self).__init__()
-        self.conv1 = nn.Sequential(
-            nn.AdaptiveAvgPool2d((1, None)),
-            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
-        )
-        self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
-        self.conv3 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
-        )
-        self.conv4 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
-        )
-        self.conv5 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
-        )
-        self.conv6 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
-        )
-        self.conv7 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
-        )
-        self.bottleneck = nn.Sequential(
-            Conv2DBNActiv(nin * 7, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
-        )
-
-    def forward(self, x):
-        _, _, h, w = x.size()
-        feat1 = F.interpolate(
-            self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
-        )
-        feat2 = self.conv2(x)
-        feat3 = self.conv3(x)
-        feat4 = self.conv4(x)
-        feat5 = self.conv5(x)
-        feat6 = self.conv6(x)
-        feat7 = self.conv7(x)
-        out = torch.cat((feat1, feat2, feat3, feat4, feat5, feat6, feat7), dim=1)
-        bottle = self.bottleneck(out)
-        return bottle
diff --git a/spaces/KarmKarma/genshinimpact-rvc-models-v2/lib/infer_pack/modules/F0Predictor/PMF0Predictor.py b/spaces/KarmKarma/genshinimpact-rvc-models-v2/lib/infer_pack/modules/F0Predictor/PMF0Predictor.py
deleted file mode 100644
index b2c592527a5966e6f8e79e8c52dc5b414246dcc6..0000000000000000000000000000000000000000
--- a/spaces/KarmKarma/genshinimpact-rvc-models-v2/lib/infer_pack/modules/F0Predictor/PMF0Predictor.py
+++ /dev/null
@@ -1,97 +0,0 @@
-from lib.infer_pack.modules.F0Predictor.F0Predictor import F0Predictor
-import parselmouth
-import numpy as np
-
-
-class PMF0Predictor(F0Predictor):
-    def __init__(self, hop_length=512, f0_min=50, f0_max=1100, sampling_rate=44100):
-        self.hop_length = hop_length
-        self.f0_min = f0_min
-        self.f0_max = f0_max
-        self.sampling_rate = sampling_rate
-
-    def interpolate_f0(self, f0):
-        """
-        对F0进行插值处理
-        """
-
-        data = np.reshape(f0, (f0.size, 1))
-
-        vuv_vector = np.zeros((data.size, 1), dtype=np.float32)
-        vuv_vector[data > 0.0] = 1.0
-        vuv_vector[data <= 0.0] = 0.0
-
-        ip_data = data
-
-        frame_number = data.size
-        last_value = 0.0
-        for i in range(frame_number):
-            if data[i] <= 0.0:
-                j = i + 1
-                for j in range(i + 1, frame_number):
-                    if data[j] > 0.0:
-                        break
-                if j < frame_number - 1:
-                    if last_value > 0.0:
-                        step = (data[j] - data[i - 1]) / float(j - i)
-                        for k in range(i, j):
-                            ip_data[k] = data[i - 1] + step * (k - i + 1)
-                    else:
-                        for k in range(i, j):
-                            ip_data[k] = data[j]
-                else:
-                    for k in range(i, frame_number):
-                        ip_data[k] = last_value
-            else:
-                ip_data[i] = data[i]  # 这里可能存在一个没有必要的拷贝
-                last_value = data[i]
-
-        return ip_data[:, 0], vuv_vector[:, 0]
-
-    def compute_f0(self, wav, p_len=None):
-        x = wav
-        if p_len is None:
-            p_len = x.shape[0] // self.hop_length
-        else:
-            assert abs(p_len - x.shape[0] // self.hop_length) < 4, "pad length error"
-        time_step = self.hop_length / self.sampling_rate * 1000
-        f0 = (
-            parselmouth.Sound(x, self.sampling_rate)
-            .to_pitch_ac(
-                time_step=time_step / 1000,
-                voicing_threshold=0.6,
-                pitch_floor=self.f0_min,
-                pitch_ceiling=self.f0_max,
-            )
-            .selected_array["frequency"]
-        )
-
-        pad_size = (p_len - len(f0) + 1) // 2
-        if pad_size > 0 or p_len - len(f0) - pad_size > 0:
-            f0 = np.pad(f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant")
-        f0, uv = self.interpolate_f0(f0)
-        return f0
-
-    def compute_f0_uv(self, wav, p_len=None):
-        x = wav
-        if p_len is None:
-            p_len = x.shape[0] // self.hop_length
-        else:
-            assert abs(p_len - x.shape[0] // self.hop_length) < 4, "pad length error"
-        time_step = self.hop_length / self.sampling_rate * 1000
-        f0 = (
-            parselmouth.Sound(x, self.sampling_rate)
-            .to_pitch_ac(
-                time_step=time_step / 1000,
-                voicing_threshold=0.6,
-                pitch_floor=self.f0_min,
-                pitch_ceiling=self.f0_max,
-            )
-            .selected_array["frequency"]
-        )
-
-        pad_size = (p_len - len(f0) + 1) // 2
-        if pad_size > 0 or p_len - len(f0) - pad_size > 0:
-            f0 = np.pad(f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant")
-        f0, uv = self.interpolate_f0(f0)
-        return f0, uv
diff --git a/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/ppg2mel/__init__.py b/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/ppg2mel/__init__.py
deleted file mode 100644
index cc54db831d54907582206146e26cf797828787c3..0000000000000000000000000000000000000000
--- a/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/ppg2mel/__init__.py
+++ /dev/null
@@ -1,209 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2020 Songxiang Liu
-# Apache 2.0
-
-from typing import List
-
-import torch
-import torch.nn.functional as F
-
-import numpy as np
-
-from .utils.abs_model import AbsMelDecoder
-from .rnn_decoder_mol import Decoder
-from .utils.cnn_postnet import Postnet
-from .utils.vc_utils import get_mask_from_lengths
-
-from utils.load_yaml import HpsYaml
-
-class MelDecoderMOLv2(AbsMelDecoder):
-    """Use an encoder to preprocess ppg."""
-    def __init__(
-        self,
-        num_speakers: int,
-        spk_embed_dim: int,
-        bottle_neck_feature_dim: int,
-        encoder_dim: int = 256,
-        encoder_downsample_rates: List = [2, 2],
-        attention_rnn_dim: int = 512,
-        decoder_rnn_dim: int = 512,
-        num_decoder_rnn_layer: int = 1,
-        concat_context_to_last: bool = True,
-        prenet_dims: List = [256, 128],
-        num_mixtures: int = 5,
-        frames_per_step: int = 2,
-        mask_padding: bool = True,
-    ):
-        super().__init__()
-        
-        self.mask_padding = mask_padding
-        self.bottle_neck_feature_dim = bottle_neck_feature_dim
-        self.num_mels = 80
-        self.encoder_down_factor=np.cumprod(encoder_downsample_rates)[-1]
-        self.frames_per_step = frames_per_step
-        self.use_spk_dvec = True
-
-        input_dim = bottle_neck_feature_dim
-        
-        # Downsampling convolution
-        self.bnf_prenet = torch.nn.Sequential(
-            torch.nn.Conv1d(input_dim, encoder_dim, kernel_size=1, bias=False),
-            torch.nn.LeakyReLU(0.1),
-
-            torch.nn.InstanceNorm1d(encoder_dim, affine=False),
-            torch.nn.Conv1d(
-                encoder_dim, encoder_dim, 
-                kernel_size=2*encoder_downsample_rates[0], 
-                stride=encoder_downsample_rates[0], 
-                padding=encoder_downsample_rates[0]//2,
-            ),
-            torch.nn.LeakyReLU(0.1),
-            
-            torch.nn.InstanceNorm1d(encoder_dim, affine=False),
-            torch.nn.Conv1d(
-                encoder_dim, encoder_dim, 
-                kernel_size=2*encoder_downsample_rates[1], 
-                stride=encoder_downsample_rates[1], 
-                padding=encoder_downsample_rates[1]//2,
-            ),
-            torch.nn.LeakyReLU(0.1),
-
-            torch.nn.InstanceNorm1d(encoder_dim, affine=False),
-        )
-        decoder_enc_dim = encoder_dim
-        self.pitch_convs = torch.nn.Sequential(
-            torch.nn.Conv1d(2, encoder_dim, kernel_size=1, bias=False),
-            torch.nn.LeakyReLU(0.1),
-
-            torch.nn.InstanceNorm1d(encoder_dim, affine=False),
-            torch.nn.Conv1d(
-                encoder_dim, encoder_dim, 
-                kernel_size=2*encoder_downsample_rates[0], 
-                stride=encoder_downsample_rates[0], 
-                padding=encoder_downsample_rates[0]//2,
-            ),
-            torch.nn.LeakyReLU(0.1),
-            
-            torch.nn.InstanceNorm1d(encoder_dim, affine=False),
-            torch.nn.Conv1d(
-                encoder_dim, encoder_dim, 
-                kernel_size=2*encoder_downsample_rates[1], 
-                stride=encoder_downsample_rates[1], 
-                padding=encoder_downsample_rates[1]//2,
-            ),
-            torch.nn.LeakyReLU(0.1),
-
-            torch.nn.InstanceNorm1d(encoder_dim, affine=False),
-        )
-        
-        self.reduce_proj = torch.nn.Linear(encoder_dim + spk_embed_dim, encoder_dim)
-
-        # Decoder
-        self.decoder = Decoder(
-            enc_dim=decoder_enc_dim,
-            num_mels=self.num_mels,
-            frames_per_step=frames_per_step,
-            attention_rnn_dim=attention_rnn_dim,
-            decoder_rnn_dim=decoder_rnn_dim,
-            num_decoder_rnn_layer=num_decoder_rnn_layer,
-            prenet_dims=prenet_dims,
-            num_mixtures=num_mixtures,
-            use_stop_tokens=True,
-            concat_context_to_last=concat_context_to_last,
-            encoder_down_factor=self.encoder_down_factor,
-        )
-
-        # Mel-Spec Postnet: some residual CNN layers
-        self.postnet = Postnet()
-    
-    def parse_output(self, outputs, output_lengths=None):
-        if self.mask_padding and output_lengths is not None:
-            mask = ~get_mask_from_lengths(output_lengths, outputs[0].size(1))
-            mask = mask.unsqueeze(2).expand(mask.size(0), mask.size(1), self.num_mels)
-            outputs[0].data.masked_fill_(mask, 0.0)
-            outputs[1].data.masked_fill_(mask, 0.0)
-        return outputs
-
-    def forward(
-        self,
-        bottle_neck_features: torch.Tensor,
-        feature_lengths: torch.Tensor,
-        speech: torch.Tensor,
-        speech_lengths: torch.Tensor,
-        logf0_uv: torch.Tensor = None,
-        spembs: torch.Tensor = None,
-        output_att_ws: bool = False,
-    ):
-        decoder_inputs = self.bnf_prenet(
-            bottle_neck_features.transpose(1, 2)
-        ).transpose(1, 2)
-        logf0_uv = self.pitch_convs(logf0_uv.transpose(1, 2)).transpose(1, 2)
-        decoder_inputs = decoder_inputs + logf0_uv
-            
-        assert spembs is not None
-        spk_embeds = F.normalize(
-            spembs).unsqueeze(1).expand(-1, decoder_inputs.size(1), -1)
-        decoder_inputs = torch.cat([decoder_inputs, spk_embeds], dim=-1)
-        decoder_inputs = self.reduce_proj(decoder_inputs)
-        
-        # (B, num_mels, T_dec)
-        T_dec = torch.div(feature_lengths, int(self.encoder_down_factor), rounding_mode='floor')
-        mel_outputs, predicted_stop, alignments = self.decoder(
-            decoder_inputs, speech, T_dec)
-        ## Post-processing
-        mel_outputs_postnet = self.postnet(mel_outputs.transpose(1, 2)).transpose(1, 2)
-        mel_outputs_postnet = mel_outputs + mel_outputs_postnet
-        if output_att_ws: 
-            return self.parse_output(
-                [mel_outputs, mel_outputs_postnet, predicted_stop, alignments], speech_lengths)
-        else:
-            return self.parse_output(
-                [mel_outputs, mel_outputs_postnet, predicted_stop], speech_lengths)
-
-        # return mel_outputs, mel_outputs_postnet
-
-    def inference(
-        self,
-        bottle_neck_features: torch.Tensor,
-        logf0_uv: torch.Tensor = None,
-        spembs: torch.Tensor = None,
-    ):
-        decoder_inputs = self.bnf_prenet(bottle_neck_features.transpose(1, 2)).transpose(1, 2)
-        logf0_uv = self.pitch_convs(logf0_uv.transpose(1, 2)).transpose(1, 2)
-        decoder_inputs = decoder_inputs + logf0_uv
-
-        assert spembs is not None
-        spk_embeds = F.normalize(
-            spembs).unsqueeze(1).expand(-1, decoder_inputs.size(1), -1)
-        bottle_neck_features = torch.cat([decoder_inputs, spk_embeds], dim=-1)
-        bottle_neck_features = self.reduce_proj(bottle_neck_features)
-
-        ## Decoder
-        if bottle_neck_features.size(0) > 1:
-            mel_outputs, alignments = self.decoder.inference_batched(bottle_neck_features)
-        else:
-            mel_outputs, alignments = self.decoder.inference(bottle_neck_features,)
-        ## Post-processing
-        mel_outputs_postnet = self.postnet(mel_outputs.transpose(1, 2)).transpose(1, 2)
-        mel_outputs_postnet = mel_outputs + mel_outputs_postnet
-        # outputs = mel_outputs_postnet[0]
-        
-        return mel_outputs[0], mel_outputs_postnet[0], alignments[0]
-
-def load_model(model_file, device=None):
-    # search a config file
-    model_config_fpaths = list(model_file.parent.rglob("*.yaml"))
-    if len(model_config_fpaths) == 0:
-        raise "No model yaml config found for convertor"
-    if device is None:
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-    model_config = HpsYaml(model_config_fpaths[0])
-    ppg2mel_model = MelDecoderMOLv2(
-        **model_config["model"]
-    ).to(device)
-    ckpt = torch.load(model_file, map_location=device)
-    ppg2mel_model.load_state_dict(ckpt["model"])
-    ppg2mel_model.eval()
-    return ppg2mel_model
diff --git a/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/synthesizer/inference.py b/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/synthesizer/inference.py
deleted file mode 100644
index 3ff856bdf4d43fd09dec1061818590937fef6512..0000000000000000000000000000000000000000
--- a/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/synthesizer/inference.py
+++ /dev/null
@@ -1,187 +0,0 @@
-import torch
-from synthesizer import audio
-from synthesizer.hparams import hparams
-from synthesizer.models.tacotron import Tacotron
-from synthesizer.utils.symbols import symbols
-from synthesizer.utils.text import text_to_sequence
-from vocoder.display import simple_table
-from pathlib import Path
-from typing import Union, List
-import numpy as np
-import librosa
-from utils import logmmse
-import json
-from pypinyin import lazy_pinyin, Style
-
-class Synthesizer:
-    sample_rate = hparams.sample_rate
-    hparams = hparams
-    
-    def __init__(self, model_fpath: Path, verbose=True):
-        """
-        The model isn't instantiated and loaded in memory until needed or until load() is called.
-        
-        :param model_fpath: path to the trained model file
-        :param verbose: if False, prints less information when using the model
-        """
-        self.model_fpath = model_fpath
-        self.verbose = verbose
- 
-        # Check for GPU
-        if torch.cuda.is_available():
-            self.device = torch.device("cuda")
-        else:
-            self.device = torch.device("cpu")
-        if self.verbose:
-            print("Synthesizer using device:", self.device)
-        
-        # Tacotron model will be instantiated later on first use.
-        self._model = None
-
-    def is_loaded(self):
-        """
-        Whether the model is loaded in memory.
-        """
-        return self._model is not None
-    
-    def load(self):
-        # Try to scan config file
-        model_config_fpaths = list(self.model_fpath.parent.rglob("*.json"))
-        if len(model_config_fpaths)>0 and model_config_fpaths[0].exists():
-            with model_config_fpaths[0].open("r", encoding="utf-8") as f:
-                hparams.loadJson(json.load(f))
-        """
-        Instantiates and loads the model given the weights file that was passed in the constructor.
-        """
-        self._model = Tacotron(embed_dims=hparams.tts_embed_dims,
-                               num_chars=len(symbols),
-                               encoder_dims=hparams.tts_encoder_dims,
-                               decoder_dims=hparams.tts_decoder_dims,
-                               n_mels=hparams.num_mels,
-                               fft_bins=hparams.num_mels,
-                               postnet_dims=hparams.tts_postnet_dims,
-                               encoder_K=hparams.tts_encoder_K,
-                               lstm_dims=hparams.tts_lstm_dims,
-                               postnet_K=hparams.tts_postnet_K,
-                               num_highways=hparams.tts_num_highways,
-                               dropout=hparams.tts_dropout,
-                               stop_threshold=hparams.tts_stop_threshold,
-                               speaker_embedding_size=hparams.speaker_embedding_size).to(self.device)
-
-        self._model.load(self.model_fpath, self.device)
-        self._model.eval()
-
-        if self.verbose:
-            print("Loaded synthesizer \"%s\" trained to step %d" % (self.model_fpath.name, self._model.state_dict()["step"]))
-
-    def synthesize_spectrograms(self, texts: List[str],
-                                embeddings: Union[np.ndarray, List[np.ndarray]],
-                                return_alignments=False, style_idx=0, min_stop_token=5, steps=2000):
-        """
-        Synthesizes mel spectrograms from texts and speaker embeddings.
-
-        :param texts: a list of N text prompts to be synthesized
-        :param embeddings: a numpy array or list of speaker embeddings of shape (N, 256) 
-        :param return_alignments: if True, a matrix representing the alignments between the 
-        characters
-        and each decoder output step will be returned for each spectrogram
-        :return: a list of N melspectrograms as numpy arrays of shape (80, Mi), where Mi is the 
-        sequence length of spectrogram i, and possibly the alignments.
-        """
-        # Load the model on the first request.
-        if not self.is_loaded():
-            self.load()
-
-            # Print some info about the model when it is loaded            
-            tts_k = self._model.get_step() // 1000
-
-            simple_table([("Tacotron", str(tts_k) + "k"),
-                        ("r", self._model.r)])
-        
-        print("Read " + str(texts))
-        texts = [" ".join(lazy_pinyin(v, style=Style.TONE3, neutral_tone_with_five=True)) for v in texts]
-        print("Synthesizing " + str(texts))
-        # Preprocess text inputs
-        inputs = [text_to_sequence(text, hparams.tts_cleaner_names) for text in texts]
-        if not isinstance(embeddings, list):
-            embeddings = [embeddings]
-
-        # Batch inputs
-        batched_inputs = [inputs[i:i+hparams.synthesis_batch_size]
-                             for i in range(0, len(inputs), hparams.synthesis_batch_size)]
-        batched_embeds = [embeddings[i:i+hparams.synthesis_batch_size]
-                             for i in range(0, len(embeddings), hparams.synthesis_batch_size)]
-
-        specs = []
-        for i, batch in enumerate(batched_inputs, 1):
-            if self.verbose:
-                print(f"\n| Generating {i}/{len(batched_inputs)}")
-
-            # Pad texts so they are all the same length
-            text_lens = [len(text) for text in batch]
-            max_text_len = max(text_lens)
-            chars = [pad1d(text, max_text_len) for text in batch]
-            chars = np.stack(chars)
-
-            # Stack speaker embeddings into 2D array for batch processing
-            speaker_embeds = np.stack(batched_embeds[i-1])
-
-            # Convert to tensor
-            chars = torch.tensor(chars).long().to(self.device)
-            speaker_embeddings = torch.tensor(speaker_embeds).float().to(self.device)
-
-            # Inference
-            _, mels, alignments = self._model.generate(chars, speaker_embeddings, style_idx=style_idx, min_stop_token=min_stop_token, steps=steps)
-            mels = mels.detach().cpu().numpy()
-            for m in mels:
-                # Trim silence from end of each spectrogram
-                while np.max(m[:, -1]) < hparams.tts_stop_threshold:
-                    m = m[:, :-1]
-                specs.append(m)
-
-        if self.verbose:
-            print("\n\nDone.\n")
-        return (specs, alignments) if return_alignments else specs
-
-    @staticmethod
-    def load_preprocess_wav(fpath):
-        """
-        Loads and preprocesses an audio file under the same conditions the audio files were used to
-        train the synthesizer. 
-        """
-        wav = librosa.load(path=str(fpath), sr=hparams.sample_rate)[0]
-        if hparams.rescale:
-            wav = wav / np.abs(wav).max() * hparams.rescaling_max
-        # denoise
-        if len(wav) > hparams.sample_rate*(0.3+0.1):
-            noise_wav = np.concatenate([wav[:int(hparams.sample_rate*0.15)],
-                                        wav[-int(hparams.sample_rate*0.15):]])
-            profile = logmmse.profile_noise(noise_wav, hparams.sample_rate)
-            wav = logmmse.denoise(wav, profile)
-        return wav
-
-    @staticmethod
-    def make_spectrogram(fpath_or_wav: Union[str, Path, np.ndarray]):
-        """
-        Creates a mel spectrogram from an audio file in the same manner as the mel spectrograms that 
-        were fed to the synthesizer when training.
-        """
-        if isinstance(fpath_or_wav, str) or isinstance(fpath_or_wav, Path):
-            wav = Synthesizer.load_preprocess_wav(fpath_or_wav)
-        else:
-            wav = fpath_or_wav
-        
-        mel_spectrogram = audio.melspectrogram(wav, hparams).astype(np.float32)
-        return mel_spectrogram
-    
-    @staticmethod
-    def griffin_lim(mel):
-        """
-        Inverts a mel spectrogram using Griffin-Lim. The mel spectrogram is expected to have been built
-        with the same parameters present in hparams.py.
-        """
-        return audio.inv_mel_spectrogram(mel, hparams)
-
-
-def pad1d(x, max_len, pad_value=0):
-    return np.pad(x, (0, max_len - len(x)), mode="constant", constant_values=pad_value)
diff --git a/spaces/Kimata/Sanskrit-TTS/indic_nlp_library/docs/Makefile b/spaces/Kimata/Sanskrit-TTS/indic_nlp_library/docs/Makefile
deleted file mode 100644
index faf86259fdbcb0dff091c22d980623b622f2bbd4..0000000000000000000000000000000000000000
--- a/spaces/Kimata/Sanskrit-TTS/indic_nlp_library/docs/Makefile
+++ /dev/null
@@ -1,153 +0,0 @@
-# Makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line.
-SPHINXOPTS    =
-SPHINXBUILD   = sphinx-build
-PAPER         =
-BUILDDIR      = _build
-
-# Internal variables.
-PAPEROPT_a4     = -D latex_paper_size=a4
-PAPEROPT_letter = -D latex_paper_size=letter
-ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-# the i18n builder cannot share the environment and doctrees with the others
-I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-
-.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
-
-help:
-	@echo "Please use \`make <target>' where <target> is one of"
-	@echo "  html       to make standalone HTML files"
-	@echo "  dirhtml    to make HTML files named index.html in directories"
-	@echo "  singlehtml to make a single large HTML file"
-	@echo "  pickle     to make pickle files"
-	@echo "  json       to make JSON files"
-	@echo "  htmlhelp   to make HTML files and a HTML help project"
-	@echo "  qthelp     to make HTML files and a qthelp project"
-	@echo "  devhelp    to make HTML files and a Devhelp project"
-	@echo "  epub       to make an epub"
-	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
-	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
-	@echo "  text       to make text files"
-	@echo "  man        to make manual pages"
-	@echo "  texinfo    to make Texinfo files"
-	@echo "  info       to make Texinfo files and run them through makeinfo"
-	@echo "  gettext    to make PO message catalogs"
-	@echo "  changes    to make an overview of all changed/added/deprecated items"
-	@echo "  linkcheck  to check all external links for integrity"
-	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
-
-clean:
-	-rm -rf $(BUILDDIR)/*
-
-html:
-	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
-
-dirhtml:
-	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
-
-singlehtml:
-	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
-	@echo
-	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
-
-pickle:
-	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
-	@echo
-	@echo "Build finished; now you can process the pickle files."
-
-json:
-	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
-	@echo
-	@echo "Build finished; now you can process the JSON files."
-
-htmlhelp:
-	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
-	@echo
-	@echo "Build finished; now you can run HTML Help Workshop with the" \
-	      ".hhp project file in $(BUILDDIR)/htmlhelp."
-
-qthelp:
-	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
-	@echo
-	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
-	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
-	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/IndicNLPLibrary.qhcp"
-	@echo "To view the help file:"
-	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/IndicNLPLibrary.qhc"
-
-devhelp:
-	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
-	@echo
-	@echo "Build finished."
-	@echo "To view the help file:"
-	@echo "# mkdir -p $$HOME/.local/share/devhelp/IndicNLPLibrary"
-	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/IndicNLPLibrary"
-	@echo "# devhelp"
-
-epub:
-	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
-	@echo
-	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
-
-latex:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo
-	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
-	@echo "Run \`make' in that directory to run these through (pdf)latex" \
-	      "(use \`make latexpdf' here to do that automatically)."
-
-latexpdf:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through pdflatex..."
-	$(MAKE) -C $(BUILDDIR)/latex all-pdf
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
-text:
-	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
-	@echo
-	@echo "Build finished. The text files are in $(BUILDDIR)/text."
-
-man:
-	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
-	@echo
-	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
-
-texinfo:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo
-	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
-	@echo "Run \`make' in that directory to run these through makeinfo" \
-	      "(use \`make info' here to do that automatically)."
-
-info:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo "Running Texinfo files through makeinfo..."
-	make -C $(BUILDDIR)/texinfo info
-	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
-
-gettext:
-	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
-	@echo
-	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
-
-changes:
-	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
-	@echo
-	@echo "The overview file is in $(BUILDDIR)/changes."
-
-linkcheck:
-	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
-	@echo
-	@echo "Link check complete; look for any errors in the above output " \
-	      "or in $(BUILDDIR)/linkcheck/output.txt."
-
-doctest:
-	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
-	@echo "Testing of doctests in the sources finished, look at the " \
-	      "results in $(BUILDDIR)/doctest/output.txt."
diff --git a/spaces/Laihiujin/OneFormer/oneformer/modeling/pixel_decoder/fpn.py b/spaces/Laihiujin/OneFormer/oneformer/modeling/pixel_decoder/fpn.py
deleted file mode 100644
index a56b89c5b0f67da8ef38563b201ca757e6811152..0000000000000000000000000000000000000000
--- a/spaces/Laihiujin/OneFormer/oneformer/modeling/pixel_decoder/fpn.py
+++ /dev/null
@@ -1,312 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import logging
-import numpy as np
-from typing import Callable, Dict, List, Optional, Tuple, Union
-
-import fvcore.nn.weight_init as weight_init
-import torch
-from torch import nn
-from torch.nn import functional as F
-from torch.nn.init import xavier_uniform_, constant_, uniform_, normal_
-from torch.cuda.amp import autocast
-
-from detectron2.config import configurable
-from detectron2.layers import Conv2d, DeformConv, ShapeSpec, get_norm
-from detectron2.modeling import SEM_SEG_HEADS_REGISTRY
-
-from ..transformer_decoder.position_encoding import PositionEmbeddingSine
-from ..transformer_decoder.transformer import TransformerEncoder, TransformerEncoderLayer, _get_clones, _get_activation_fn
-
-
-def build_pixel_decoder(cfg, input_shape):
-    """
-    Build a pixel decoder from `cfg.MODEL.MASK_FORMER.PIXEL_DECODER_NAME`.
-    """
-    name = cfg.MODEL.SEM_SEG_HEAD.PIXEL_DECODER_NAME
-    model = SEM_SEG_HEADS_REGISTRY.get(name)(cfg, input_shape)
-    forward_features = getattr(model, "forward_features", None)
-    if not callable(forward_features):
-        raise ValueError(
-            "Only SEM_SEG_HEADS with forward_features method can be used as pixel decoder. "
-            f"Please implement forward_features for {name} to only return mask features."
-        )
-    return model
-
-
-# This is a modified FPN decoder.
-@SEM_SEG_HEADS_REGISTRY.register()
-class BasePixelDecoder(nn.Module):
-    @configurable
-    def __init__(
-        self,
-        input_shape: Dict[str, ShapeSpec],
-        *,
-        conv_dim: int,
-        mask_dim: int,
-        norm: Optional[Union[str, Callable]] = None,
-    ):
-        """
-        NOTE: this interface is experimental.
-        Args:
-            input_shape: shapes (channels and stride) of the input features
-            conv_dims: number of output channels for the intermediate conv layers.
-            mask_dim: number of output channels for the final conv layer.
-            norm (str or callable): normalization for all conv layers
-        """
-        super().__init__()
-
-        input_shape = sorted(input_shape.items(), key=lambda x: x[1].stride)
-        self.in_features = [k for k, v in input_shape]  # starting from "res2" to "res5"
-        feature_channels = [v.channels for k, v in input_shape]
-
-        lateral_convs = []
-        output_convs = []
-
-        use_bias = norm == ""
-        for idx, in_channels in enumerate(feature_channels):
-            if idx == len(self.in_features) - 1:
-                output_norm = get_norm(norm, conv_dim)
-                output_conv = Conv2d(
-                    in_channels,
-                    conv_dim,
-                    kernel_size=3,
-                    stride=1,
-                    padding=1,
-                    bias=use_bias,
-                    norm=output_norm,
-                    activation=F.relu,
-                )
-                weight_init.c2_xavier_fill(output_conv)
-                self.add_module("layer_{}".format(idx + 1), output_conv)
-
-                lateral_convs.append(None)
-                output_convs.append(output_conv)
-            else:
-                lateral_norm = get_norm(norm, conv_dim)
-                output_norm = get_norm(norm, conv_dim)
-
-                lateral_conv = Conv2d(
-                    in_channels, conv_dim, kernel_size=1, bias=use_bias, norm=lateral_norm
-                )
-                output_conv = Conv2d(
-                    conv_dim,
-                    conv_dim,
-                    kernel_size=3,
-                    stride=1,
-                    padding=1,
-                    bias=use_bias,
-                    norm=output_norm,
-                    activation=F.relu,
-                )
-                weight_init.c2_xavier_fill(lateral_conv)
-                weight_init.c2_xavier_fill(output_conv)
-                self.add_module("adapter_{}".format(idx + 1), lateral_conv)
-                self.add_module("layer_{}".format(idx + 1), output_conv)
-
-                lateral_convs.append(lateral_conv)
-                output_convs.append(output_conv)
-        # Place convs into top-down order (from low to high resolution)
-        # to make the top-down computation in forward clearer.
-        self.lateral_convs = lateral_convs[::-1]
-        self.output_convs = output_convs[::-1]
-
-        self.mask_dim = mask_dim
-        self.mask_features = Conv2d(
-            conv_dim,
-            mask_dim,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-        )
-        weight_init.c2_xavier_fill(self.mask_features)
-
-        self.oneformer_num_feature_levels = 3  # always use 3 scales
-
-    @classmethod
-    def from_config(cls, cfg, input_shape: Dict[str, ShapeSpec]):
-        ret = {}
-        ret["input_shape"] = {
-            k: v for k, v in input_shape.items() if k in cfg.MODEL.SEM_SEG_HEAD.IN_FEATURES
-        }
-        ret["conv_dim"] = cfg.MODEL.SEM_SEG_HEAD.CONVS_DIM
-        ret["mask_dim"] = cfg.MODEL.SEM_SEG_HEAD.MASK_DIM
-        ret["norm"] = cfg.MODEL.SEM_SEG_HEAD.NORM
-        return ret
-
-    def forward_features(self, features):
-        multi_scale_features = []
-        num_cur_levels = 0
-        # Reverse feature maps into top-down order (from low to high resolution)
-        for idx, f in enumerate(self.in_features[::-1]):
-            x = features[f]
-            lateral_conv = self.lateral_convs[idx]
-            output_conv = self.output_convs[idx]
-            if lateral_conv is None:
-                y = output_conv(x)
-            else:
-                cur_fpn = lateral_conv(x)
-                # Following FPN implementation, we use nearest upsampling here
-                y = cur_fpn + F.interpolate(y, size=cur_fpn.shape[-2:], mode="nearest")
-                y = output_conv(y)
-            if num_cur_levels < self.oneformer_num_feature_levels:
-                multi_scale_features.append(y)
-                num_cur_levels += 1
-        return self.mask_features(y), None, multi_scale_features
-
-    def forward(self, features, targets=None):
-        logger = logging.getLogger(__name__)
-        logger.warning("Calling forward() may cause unpredicted behavior of PixelDecoder module.")
-        return self.forward_features(features)
-
-
-class TransformerEncoderOnly(nn.Module):
-    def __init__(
-        self,
-        d_model=512,
-        nhead=8,
-        num_encoder_layers=6,
-        dim_feedforward=2048,
-        dropout=0.1,
-        activation="relu",
-        normalize_before=False,
-    ):
-        super().__init__()
-
-        encoder_layer = TransformerEncoderLayer(
-            d_model, nhead, dim_feedforward, dropout, activation, normalize_before
-        )
-        encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
-        self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
-
-        self._reset_parameters()
-
-        self.d_model = d_model
-        self.nhead = nhead
-
-    def _reset_parameters(self):
-        for p in self.parameters():
-            if p.dim() > 1:
-                nn.init.xavier_uniform_(p)
-
-    def forward(self, src, mask, pos_embed):
-        # flatten NxCxHxW to HWxNxC
-        bs, c, h, w = src.shape
-        src = src.flatten(2).permute(2, 0, 1)
-        pos_embed = pos_embed.flatten(2).permute(2, 0, 1)
-        if mask is not None:
-            mask = mask.flatten(1)
-
-        memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)
-        return memory.permute(1, 2, 0).view(bs, c, h, w)
-
-
-# This is a modified FPN decoder with extra Transformer encoder that processes the lowest-resolution feature map.
-@SEM_SEG_HEADS_REGISTRY.register()
-class TransformerEncoderPixelDecoder(BasePixelDecoder):
-    @configurable
-    def __init__(
-        self,
-        input_shape: Dict[str, ShapeSpec],
-        *,
-        transformer_dropout: float,
-        transformer_nheads: int,
-        transformer_dim_feedforward: int,
-        transformer_enc_layers: int,
-        transformer_pre_norm: bool,
-        conv_dim: int,
-        mask_dim: int,
-        norm: Optional[Union[str, Callable]] = None,
-    ):
-        """
-        NOTE: this interface is experimental.
-        Args:
-            input_shape: shapes (channels and stride) of the input features
-            transformer_dropout: dropout probability in transformer
-            transformer_nheads: number of heads in transformer
-            transformer_dim_feedforward: dimension of feedforward network
-            transformer_enc_layers: number of transformer encoder layers
-            transformer_pre_norm: whether to use pre-layernorm or not
-            conv_dims: number of output channels for the intermediate conv layers.
-            mask_dim: number of output channels for the final conv layer.
-            norm (str or callable): normalization for all conv layers
-        """
-        super().__init__(input_shape, conv_dim=conv_dim, mask_dim=mask_dim, norm=norm)
-
-        input_shape = sorted(input_shape.items(), key=lambda x: x[1].stride)
-        self.in_features = [k for k, v in input_shape]  # starting from "res2" to "res5"
-        feature_strides = [v.stride for k, v in input_shape]
-        feature_channels = [v.channels for k, v in input_shape]
-
-        in_channels = feature_channels[len(self.in_features) - 1]
-        self.input_proj = Conv2d(in_channels, conv_dim, kernel_size=1)
-        weight_init.c2_xavier_fill(self.input_proj)
-        self.transformer = TransformerEncoderOnly(
-            d_model=conv_dim,
-            dropout=transformer_dropout,
-            nhead=transformer_nheads,
-            dim_feedforward=transformer_dim_feedforward,
-            num_encoder_layers=transformer_enc_layers,
-            normalize_before=transformer_pre_norm,
-        )
-        N_steps = conv_dim // 2
-        self.pe_layer = PositionEmbeddingSine(N_steps, normalize=True)
-
-        # update layer
-        use_bias = norm == ""
-        output_norm = get_norm(norm, conv_dim)
-        output_conv = Conv2d(
-            conv_dim,
-            conv_dim,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            bias=use_bias,
-            norm=output_norm,
-            activation=F.relu,
-        )
-        weight_init.c2_xavier_fill(output_conv)
-        delattr(self, "layer_{}".format(len(self.in_features)))
-        self.add_module("layer_{}".format(len(self.in_features)), output_conv)
-        self.output_convs[0] = output_conv
-
-    @classmethod
-    def from_config(cls, cfg, input_shape: Dict[str, ShapeSpec]):
-        ret = super().from_config(cfg, input_shape)
-        ret["transformer_dropout"] = cfg.MODEL.MASK_FORMER.DROPOUT
-        ret["transformer_nheads"] = cfg.MODEL.MASK_FORMER.NHEADS
-        ret["transformer_dim_feedforward"] = cfg.MODEL.MASK_FORMER.DIM_FEEDFORWARD
-        ret[
-            "transformer_enc_layers"
-        ] = cfg.MODEL.SEM_SEG_HEAD.TRANSFORMER_ENC_LAYERS  # a separate config
-        ret["transformer_pre_norm"] = cfg.MODEL.MASK_FORMER.PRE_NORM
-        return ret
-
-    def forward_features(self, features):
-        multi_scale_features = []
-        num_cur_levels = 0
-        # Reverse feature maps into top-down order (from low to high resolution)
-        for idx, f in enumerate(self.in_features[::-1]):
-            x = features[f]
-            lateral_conv = self.lateral_convs[idx]
-            output_conv = self.output_convs[idx]
-            if lateral_conv is None:
-                transformer = self.input_proj(x)
-                pos = self.pe_layer(x)
-                transformer = self.transformer(transformer, None, pos)
-                y = output_conv(transformer)
-                # save intermediate feature as input to Transformer decoder
-                transformer_encoder_features = transformer
-            else:
-                cur_fpn = lateral_conv(x)
-                # Following FPN implementation, we use nearest upsampling here
-                y = cur_fpn + F.interpolate(y, size=cur_fpn.shape[-2:], mode="nearest")
-                y = output_conv(y)
-            if num_cur_levels < self.oneformer_num_feature_levels:
-                multi_scale_features.append(y)
-                num_cur_levels += 1
-        return self.mask_features(y), transformer_encoder_features, multi_scale_features
-
-    def forward(self, features, targets=None):
-        logger = logging.getLogger(__name__)
-        logger.warning("Calling forward() may cause unpredicted behavior of PixelDecoder module.")
-        return self.forward_features(features)
diff --git a/spaces/Lamai/LAMAIGPT/autogpt/speech/brian.py b/spaces/Lamai/LAMAIGPT/autogpt/speech/brian.py
deleted file mode 100644
index 821fdf2f482a9cfa928e5c9680152ad6766d8326..0000000000000000000000000000000000000000
--- a/spaces/Lamai/LAMAIGPT/autogpt/speech/brian.py
+++ /dev/null
@@ -1,40 +0,0 @@
-""" Brian speech module for autogpt """
-import os
-
-import requests
-from playsound import playsound
-
-from autogpt.speech.base import VoiceBase
-
-
-class BrianSpeech(VoiceBase):
-    """Brian speech module for autogpt"""
-
-    def _setup(self) -> None:
-        """Setup the voices, API key, etc."""
-        pass
-
-    def _speech(self, text: str, _: int = 0) -> bool:
-        """Speak text using Brian with the streamelements API
-
-        Args:
-            text (str): The text to speak
-
-        Returns:
-            bool: True if the request was successful, False otherwise
-        """
-        tts_url = (
-            f"https://api.streamelements.com/kappa/v2/speech?voice=Brian&text={text}"
-        )
-        response = requests.get(tts_url)
-
-        if response.status_code == 200:
-            with open("speech.mp3", "wb") as f:
-                f.write(response.content)
-            playsound("speech.mp3")
-            os.remove("speech.mp3")
-            return True
-        else:
-            print("Request failed with status code:", response.status_code)
-            print("Response content:", response.content)
-            return False
diff --git a/spaces/LaynzKunz/Aesthetic_RVC_Inference_HF/lib/infer/infer_libs/uvr5_pack/demucs/train.py b/spaces/LaynzKunz/Aesthetic_RVC_Inference_HF/lib/infer/infer_libs/uvr5_pack/demucs/train.py
deleted file mode 100644
index 6bd221279dc986a6df1a8d7b4d4444bb822a1cb3..0000000000000000000000000000000000000000
--- a/spaces/LaynzKunz/Aesthetic_RVC_Inference_HF/lib/infer/infer_libs/uvr5_pack/demucs/train.py
+++ /dev/null
@@ -1,127 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import sys
-
-import tqdm
-from torch.utils.data import DataLoader
-from torch.utils.data.distributed import DistributedSampler
-
-from .utils import apply_model, average_metric, center_trim
-
-
-def train_model(epoch,
-                dataset,
-                model,
-                criterion,
-                optimizer,
-                augment,
-                quantizer=None,
-                diffq=0,
-                repeat=1,
-                device="cpu",
-                seed=None,
-                workers=4,
-                world_size=1,
-                batch_size=16):
-
-    if world_size > 1:
-        sampler = DistributedSampler(dataset)
-        sampler_epoch = epoch * repeat
-        if seed is not None:
-            sampler_epoch += seed * 1000
-        sampler.set_epoch(sampler_epoch)
-        batch_size //= world_size
-        loader = DataLoader(dataset, batch_size=batch_size, sampler=sampler, num_workers=workers)
-    else:
-        loader = DataLoader(dataset, batch_size=batch_size, num_workers=workers, shuffle=True)
-    current_loss = 0
-    model_size = 0
-    for repetition in range(repeat):
-        tq = tqdm.tqdm(loader,
-                       ncols=120,
-                       desc=f"[{epoch:03d}] train ({repetition + 1}/{repeat})",
-                       leave=False,
-                       file=sys.stdout,
-                       unit=" batch")
-        total_loss = 0
-        for idx, sources in enumerate(tq):
-            if len(sources) < batch_size:
-                # skip uncomplete batch for augment.Remix to work properly
-                continue
-            sources = sources.to(device)
-            sources = augment(sources)
-            mix = sources.sum(dim=1)
-
-            estimates = model(mix)
-            sources = center_trim(sources, estimates)
-            loss = criterion(estimates, sources)
-            model_size = 0
-            if quantizer is not None:
-                model_size = quantizer.model_size()
-
-            train_loss = loss + diffq * model_size
-            train_loss.backward()
-            grad_norm = 0
-            for p in model.parameters():
-                if p.grad is not None:
-                    grad_norm += p.grad.data.norm()**2
-            grad_norm = grad_norm**0.5
-            optimizer.step()
-            optimizer.zero_grad()
-
-            if quantizer is not None:
-                model_size = model_size.item()
-
-            total_loss += loss.item()
-            current_loss = total_loss / (1 + idx)
-            tq.set_postfix(loss=f"{current_loss:.4f}", ms=f"{model_size:.2f}",
-                           grad=f"{grad_norm:.5f}")
-
-            # free some space before next round
-            del sources, mix, estimates, loss, train_loss
-
-        if world_size > 1:
-            sampler.epoch += 1
-
-    if world_size > 1:
-        current_loss = average_metric(current_loss)
-    return current_loss, model_size
-
-
-def validate_model(epoch,
-                   dataset,
-                   model,
-                   criterion,
-                   device="cpu",
-                   rank=0,
-                   world_size=1,
-                   shifts=0,
-                   overlap=0.25,
-                   split=False):
-    indexes = range(rank, len(dataset), world_size)
-    tq = tqdm.tqdm(indexes,
-                   ncols=120,
-                   desc=f"[{epoch:03d}] valid",
-                   leave=False,
-                   file=sys.stdout,
-                   unit=" track")
-    current_loss = 0
-    for index in tq:
-        streams = dataset[index]
-        # first five minutes to avoid OOM on --upsample models
-        streams = streams[..., :15_000_000]
-        streams = streams.to(device)
-        sources = streams[1:]
-        mix = streams[0]
-        estimates = apply_model(model, mix, shifts=shifts, split=split, overlap=overlap)
-        loss = criterion(estimates, sources)
-        current_loss += loss.item() / len(indexes)
-        del estimates, streams, sources
-
-    if world_size > 1:
-        current_loss = average_metric(current_loss, len(indexes))
-    return current_loss
diff --git a/spaces/Lbin123/Lbingo/src/lib/hooks/use-at-bottom.tsx b/spaces/Lbin123/Lbingo/src/lib/hooks/use-at-bottom.tsx
deleted file mode 100644
index d37c8cf4162adcb0064e08ecec24eb731416b045..0000000000000000000000000000000000000000
--- a/spaces/Lbin123/Lbingo/src/lib/hooks/use-at-bottom.tsx
+++ /dev/null
@@ -1,23 +0,0 @@
-import * as React from 'react'
-
-export function useAtBottom(offset = 0) {
-  const [isAtBottom, setIsAtBottom] = React.useState(false)
-
-  React.useEffect(() => {
-    const handleScroll = () => {
-      setIsAtBottom(
-        window.innerHeight + window.scrollY >=
-          document.body.offsetHeight - offset
-      )
-    }
-
-    window.addEventListener('scroll', handleScroll, { passive: true })
-    handleScroll()
-
-    return () => {
-      window.removeEventListener('scroll', handleScroll)
-    }
-  }, [offset])
-
-  return isAtBottom
-}
diff --git a/spaces/LecJackS/wolfram-alpha-query/style.css b/spaces/LecJackS/wolfram-alpha-query/style.css
deleted file mode 100644
index 114adf441e9032febb46bc056b2a8bb651075f0d..0000000000000000000000000000000000000000
--- a/spaces/LecJackS/wolfram-alpha-query/style.css
+++ /dev/null
@@ -1,28 +0,0 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}
diff --git a/spaces/Lianjd/stock_dashboard/backtrader/brokers/ibbroker.py b/spaces/Lianjd/stock_dashboard/backtrader/brokers/ibbroker.py
deleted file mode 100644
index 3f16515949400d938d4debf4ce4d00801fddc2d5..0000000000000000000000000000000000000000
--- a/spaces/Lianjd/stock_dashboard/backtrader/brokers/ibbroker.py
+++ /dev/null
@@ -1,576 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8; py-indent-offset:4 -*-
-###############################################################################
-#
-# Copyright (C) 2015-2020 Daniel Rodriguez
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-###############################################################################
-from __future__ import (absolute_import, division, print_function,
-                        unicode_literals)
-
-import collections
-from copy import copy
-from datetime import date, datetime, timedelta
-import threading
-import uuid
-
-import ib.ext.Order
-import ib.opt as ibopt
-
-from backtrader.feed import DataBase
-from backtrader import (TimeFrame, num2date, date2num, BrokerBase,
-                        Order, OrderBase, OrderData)
-from backtrader.utils.py3 import bytes, bstr, with_metaclass, queue, MAXFLOAT
-from backtrader.metabase import MetaParams
-from backtrader.comminfo import CommInfoBase
-from backtrader.position import Position
-from backtrader.stores import ibstore
-from backtrader.utils import AutoDict, AutoOrderedDict
-from backtrader.comminfo import CommInfoBase
-
-bytes = bstr  # py2/3 need for ibpy
-
-
-class IBOrderState(object):
-    # wraps OrderState object and can print it
-    _fields = ['status', 'initMargin', 'maintMargin', 'equityWithLoan',
-               'commission', 'minCommission', 'maxCommission',
-               'commissionCurrency', 'warningText']
-
-    def __init__(self, orderstate):
-        for f in self._fields:
-            fname = 'm_' + f
-            setattr(self, fname, getattr(orderstate, fname))
-
-    def __str__(self):
-        txt = list()
-        txt.append('--- ORDERSTATE BEGIN')
-        for f in self._fields:
-            fname = 'm_' + f
-            txt.append('{}: {}'.format(f.capitalize(), getattr(self, fname)))
-        txt.append('--- ORDERSTATE END')
-        return '\n'.join(txt)
-
-
-class IBOrder(OrderBase, ib.ext.Order.Order):
-    '''Subclasses the IBPy order to provide the minimum extra functionality
-    needed to be compatible with the internally defined orders
-
-    Once ``OrderBase`` has processed the parameters, the __init__ method takes
-    over to use the parameter values and set the appropriate values in the
-    ib.ext.Order.Order object
-
-    Any extra parameters supplied with kwargs are applied directly to the
-    ib.ext.Order.Order object, which could be used as follows::
-
-      Example: if the 4 order execution types directly supported by
-      ``backtrader`` are not enough, in the case of for example
-      *Interactive Brokers* the following could be passed as *kwargs*::
-
-        orderType='LIT', lmtPrice=10.0, auxPrice=9.8
-
-      This would override the settings created by ``backtrader`` and
-      generate a ``LIMIT IF TOUCHED`` order with a *touched* price of 9.8
-      and a *limit* price of 10.0.
-
-    This would be done almost always from the ``Buy`` and ``Sell`` methods of
-    the ``Strategy`` subclass being used in ``Cerebro``
-    '''
-
-    def __str__(self):
-        '''Get the printout from the base class and add some ib.Order specific
-        fields'''
-        basetxt = super(IBOrder, self).__str__()
-        tojoin = [basetxt]
-        tojoin.append('Ref: {}'.format(self.ref))
-        tojoin.append('orderId: {}'.format(self.m_orderId))
-        tojoin.append('Action: {}'.format(self.m_action))
-        tojoin.append('Size (ib): {}'.format(self.m_totalQuantity))
-        tojoin.append('Lmt Price: {}'.format(self.m_lmtPrice))
-        tojoin.append('Aux Price: {}'.format(self.m_auxPrice))
-        tojoin.append('OrderType: {}'.format(self.m_orderType))
-        tojoin.append('Tif (Time in Force): {}'.format(self.m_tif))
-        tojoin.append('GoodTillDate: {}'.format(self.m_goodTillDate))
-        return '\n'.join(tojoin)
-
-    # Map backtrader order types to the ib specifics
-    _IBOrdTypes = {
-        None: bytes('MKT'),  # default
-        Order.Market: bytes('MKT'),
-        Order.Limit: bytes('LMT'),
-        Order.Close: bytes('MOC'),
-        Order.Stop: bytes('STP'),
-        Order.StopLimit: bytes('STPLMT'),
-        Order.StopTrail: bytes('TRAIL'),
-        Order.StopTrailLimit: bytes('TRAIL LIMIT'),
-    }
-
-    def __init__(self, action, **kwargs):
-
-        # Marker to indicate an openOrder has been seen with
-        # PendinCancel/Cancelled which is indication of an upcoming
-        # cancellation
-        self._willexpire = False
-
-        self.ordtype = self.Buy if action == 'BUY' else self.Sell
-
-        super(IBOrder, self).__init__()
-        ib.ext.Order.Order.__init__(self)  # Invoke 2nd base class
-
-        # Now fill in the specific IB parameters
-        self.m_orderType = self._IBOrdTypes[self.exectype]
-        self.m_permid = 0
-
-        # 'B' or 'S' should be enough
-        self.m_action = bytes(action)
-
-        # Set the prices
-        self.m_lmtPrice = 0.0
-        self.m_auxPrice = 0.0
-
-        if self.exectype == self.Market:  # is it really needed for Market?
-            pass
-        elif self.exectype == self.Close:  # is it ireally needed for Close?
-            pass
-        elif self.exectype == self.Limit:
-            self.m_lmtPrice = self.price
-        elif self.exectype == self.Stop:
-            self.m_auxPrice = self.price  # stop price / exec is market
-        elif self.exectype == self.StopLimit:
-            self.m_lmtPrice = self.pricelimit  # req limit execution
-            self.m_auxPrice = self.price  # trigger price
-        elif self.exectype == self.StopTrail:
-            if self.trailamount is not None:
-                self.m_auxPrice = self.trailamount
-            elif self.trailpercent is not None:
-                # value expected in % format ... multiply 100.0
-                self.m_trailingPercent = self.trailpercent * 100.0
-        elif self.exectype == self.StopTrailLimit:
-            self.m_trailStopPrice = self.m_lmtPrice = self.price
-            # The limit offset is set relative to the price difference in TWS
-            self.m_lmtPrice = self.pricelimit
-            if self.trailamount is not None:
-                self.m_auxPrice = self.trailamount
-            elif self.trailpercent is not None:
-                # value expected in % format ... multiply 100.0
-                self.m_trailingPercent = self.trailpercent * 100.0
-
-        self.m_totalQuantity = abs(self.size)  # ib takes only positives
-
-        self.m_transmit = self.transmit
-        if self.parent is not None:
-            self.m_parentId = self.parent.m_orderId
-
-        # Time In Force: DAY, GTC, IOC, GTD
-        if self.valid is None:
-            tif = 'GTC'  # Good til cancelled
-        elif isinstance(self.valid, (datetime, date)):
-            tif = 'GTD'  # Good til date
-            self.m_goodTillDate = bytes(self.valid.strftime('%Y%m%d %H:%M:%S'))
-        elif isinstance(self.valid, (timedelta,)):
-            if self.valid == self.DAY:
-                tif = 'DAY'
-            else:
-                tif = 'GTD'  # Good til date
-                valid = datetime.now() + self.valid  # .now, using localtime
-                self.m_goodTillDate = bytes(valid.strftime('%Y%m%d %H:%M:%S'))
-
-        elif self.valid == 0:
-            tif = 'DAY'
-        else:
-            tif = 'GTD'  # Good til date
-            valid = num2date(self.valid)
-            self.m_goodTillDate = bytes(valid.strftime('%Y%m%d %H:%M:%S'))
-
-        self.m_tif = bytes(tif)
-
-        # OCA
-        self.m_ocaType = 1  # Cancel all remaining orders with block
-
-        # pass any custom arguments to the order
-        for k in kwargs:
-            setattr(self, (not hasattr(self, k)) * 'm_' + k, kwargs[k])
-
-
-class IBCommInfo(CommInfoBase):
-    '''
-    Commissions are calculated by ib, but the trades calculations in the
-    ```Strategy`` rely on the order carrying a CommInfo object attached for the
-    calculation of the operation cost and value.
-
-    These are non-critical informations, but removing them from the trade could
-    break existing usage and it is better to provide a CommInfo objet which
-    enables those calculations even if with approvimate values.
-
-    The margin calculation is not a known in advance information with IB
-    (margin impact can be gotten from OrderState objects) and therefore it is
-    left as future exercise to get it'''
-
-    def getvaluesize(self, size, price):
-        # In real life the margin approaches the price
-        return abs(size) * price
-
-    def getoperationcost(self, size, price):
-        '''Returns the needed amount of cash an operation would cost'''
-        # Same reasoning as above
-        return abs(size) * price
-
-
-class MetaIBBroker(BrokerBase.__class__):
-    def __init__(cls, name, bases, dct):
-        '''Class has already been created ... register'''
-        # Initialize the class
-        super(MetaIBBroker, cls).__init__(name, bases, dct)
-        ibstore.IBStore.BrokerCls = cls
-
-
-class IBBroker(with_metaclass(MetaIBBroker, BrokerBase)):
-    '''Broker implementation for Interactive Brokers.
-
-    This class maps the orders/positions from Interactive Brokers to the
-    internal API of ``backtrader``.
-
-    Notes:
-
-      - ``tradeid`` is not really supported, because the profit and loss are
-        taken directly from IB. Because (as expected) calculates it in FIFO
-        manner, the pnl is not accurate for the tradeid.
-
-      - Position
-
-        If there is an open position for an asset at the beginning of
-        operaitons or orders given by other means change a position, the trades
-        calculated in the ``Strategy`` in cerebro will not reflect the reality.
-
-        To avoid this, this broker would have to do its own position
-        management which would also allow tradeid with multiple ids (profit and
-        loss would also be calculated locally), but could be considered to be
-        defeating the purpose of working with a live broker
-    '''
-    params = ()
-
-    def __init__(self, **kwargs):
-        super(IBBroker, self).__init__()
-
-        self.ib = ibstore.IBStore(**kwargs)
-
-        self.startingcash = self.cash = 0.0
-        self.startingvalue = self.value = 0.0
-
-        self._lock_orders = threading.Lock()  # control access
-        self.orderbyid = dict()  # orders by order id
-        self.executions = dict()  # notified executions
-        self.ordstatus = collections.defaultdict(dict)
-        self.notifs = queue.Queue()  # holds orders which are notified
-        self.tonotify = collections.deque()  # hold oids to be notified
-        self.positions = self.ib.positions
-
-    def start(self):
-        super(IBBroker, self).start()
-        self.ib.start(broker=self)
-
-        if self.ib.connected():
-            self.ib.reqAccountUpdates()
-            self.startingcash = self.cash = self.ib.get_acc_cash()
-            self.startingvalue = self.value = self.ib.get_acc_value()
-        else:
-            self.startingcash = self.cash = 0.0
-            self.startingvalue = self.value = 0.0
-
-    def stop(self):
-        super(IBBroker, self).stop()
-        self.ib.stop()
-
-    def getcash(self):
-        # This call cannot block if no answer is available from ib
-        self.cash = self.ib.get_acc_cash()
-        return self.cash
-
-    def getvalue(self, datas=None):
-        self.value = self.ib.get_acc_value()
-        return self.value
-
-    def getposition(self, data, clone=True):
-        return self.ib.getposition(data.tradecontract, clone=clone)
-
-    def cancel(self, order):
-        try:
-            o = self.orderbyid[order.m_orderId]
-        except (ValueError, KeyError):
-            return  # not found ... not cancellable
-
-        if order.status == Order.Cancelled:  # already cancelled
-            return
-
-        self.ib.cancelOrder(order.m_orderId)
-
-    def orderstatus(self, order):
-        try:
-            o = self.orderbyid[order.m_orderId]
-        except (ValueError, KeyError):
-            o = order
-
-        return o.status
-
-    def submit(self, order):
-        order.submit(self)
-
-        # ocoize if needed
-        if order.oco is None:  # Generate a UniqueId
-            order.m_ocaGroup = bytes(uuid.uuid4())
-        else:
-            order.m_ocaGroup = self.orderbyid[order.oco.m_orderId].m_ocaGroup
-
-        self.orderbyid[order.m_orderId] = order
-        self.ib.placeOrder(order.m_orderId, order.data.tradecontract, order)
-        self.notify(order)
-
-        return order
-
-    def getcommissioninfo(self, data):
-        contract = data.tradecontract
-        try:
-            mult = float(contract.m_multiplier)
-        except (ValueError, TypeError):
-            mult = 1.0
-
-        stocklike = contract.m_secType not in ('FUT', 'OPT', 'FOP',)
-
-        return IBCommInfo(mult=mult, stocklike=stocklike)
-
-    def _makeorder(self, action, owner, data,
-                   size, price=None, plimit=None,
-                   exectype=None, valid=None,
-                   tradeid=0, **kwargs):
-
-        order = IBOrder(action, owner=owner, data=data,
-                        size=size, price=price, pricelimit=plimit,
-                        exectype=exectype, valid=valid,
-                        tradeid=tradeid,
-                        m_clientId=self.ib.clientId,
-                        m_orderId=self.ib.nextOrderId(),
-                        **kwargs)
-
-        order.addcomminfo(self.getcommissioninfo(data))
-        return order
-
-    def buy(self, owner, data,
-            size, price=None, plimit=None,
-            exectype=None, valid=None, tradeid=0,
-            **kwargs):
-
-        order = self._makeorder(
-            'BUY',
-            owner, data, size, price, plimit, exectype, valid, tradeid,
-            **kwargs)
-
-        return self.submit(order)
-
-    def sell(self, owner, data,
-             size, price=None, plimit=None,
-             exectype=None, valid=None, tradeid=0,
-             **kwargs):
-
-        order = self._makeorder(
-            'SELL',
-            owner, data, size, price, plimit, exectype, valid, tradeid,
-            **kwargs)
-
-        return self.submit(order)
-
-    def notify(self, order):
-        self.notifs.put(order.clone())
-
-    def get_notification(self):
-        try:
-            return self.notifs.get(False)
-        except queue.Empty:
-            pass
-
-        return None
-
-    def next(self):
-        self.notifs.put(None)  # mark notificatino boundary
-
-    # Order statuses in msg
-    (SUBMITTED, FILLED, CANCELLED, INACTIVE,
-     PENDINGSUBMIT, PENDINGCANCEL, PRESUBMITTED) = (
-        'Submitted', 'Filled', 'Cancelled', 'Inactive',
-         'PendingSubmit', 'PendingCancel', 'PreSubmitted',)
-
-    def push_orderstatus(self, msg):
-        # Cancelled and Submitted with Filled = 0 can be pushed immediately
-        try:
-            order = self.orderbyid[msg.orderId]
-        except KeyError:
-            return  # not found, it was not an order
-
-        if msg.status == self.SUBMITTED and msg.filled == 0:
-            if order.status == order.Accepted:  # duplicate detection
-                return
-
-            order.accept(self)
-            self.notify(order)
-
-        elif msg.status == self.CANCELLED:
-            # duplicate detection
-            if order.status in [order.Cancelled, order.Expired]:
-                return
-
-            if order._willexpire:
-                # An openOrder has been seen with PendingCancel/Cancelled
-                # and this happens when an order expires
-                order.expire()
-            else:
-                # Pure user cancellation happens without an openOrder
-                order.cancel()
-            self.notify(order)
-
-        elif msg.status == self.PENDINGCANCEL:
-            # In theory this message should not be seen according to the docs,
-            # but other messages like PENDINGSUBMIT which are similarly
-            # described in the docs have been received in the demo
-            if order.status == order.Cancelled:  # duplicate detection
-                return
-
-            # We do nothing because the situation is handled with the 202 error
-            # code if no orderStatus with CANCELLED is seen
-            # order.cancel()
-            # self.notify(order)
-
-        elif msg.status == self.INACTIVE:
-            # This is a tricky one, because the instances seen have led to
-            # order rejection in the demo, but according to the docs there may
-            # be a number of reasons and it seems like it could be reactivated
-            if order.status == order.Rejected:  # duplicate detection
-                return
-
-            order.reject(self)
-            self.notify(order)
-
-        elif msg.status in [self.SUBMITTED, self.FILLED]:
-            # These two are kept inside the order until execdetails and
-            # commission are all in place - commission is the last to come
-            self.ordstatus[msg.orderId][msg.filled] = msg
-
-        elif msg.status in [self.PENDINGSUBMIT, self.PRESUBMITTED]:
-            # According to the docs, these statuses can only be set by the
-            # programmer but the demo account sent it back at random times with
-            # "filled"
-            if msg.filled:
-                self.ordstatus[msg.orderId][msg.filled] = msg
-        else:  # Unknown status ...
-            pass
-
-    def push_execution(self, ex):
-        self.executions[ex.m_execId] = ex
-
-    def push_commissionreport(self, cr):
-        with self._lock_orders:
-            ex = self.executions.pop(cr.m_execId)
-            oid = ex.m_orderId
-            order = self.orderbyid[oid]
-            ostatus = self.ordstatus[oid].pop(ex.m_cumQty)
-
-            position = self.getposition(order.data, clone=False)
-            pprice_orig = position.price
-            size = ex.m_shares if ex.m_side[0] == 'B' else -ex.m_shares
-            price = ex.m_price
-            # use pseudoupdate and let the updateportfolio do the real update?
-            psize, pprice, opened, closed = position.update(size, price)
-
-            # split commission between closed and opened
-            comm = cr.m_commission
-            closedcomm = comm * closed / size
-            openedcomm = comm - closedcomm
-
-            comminfo = order.comminfo
-            closedvalue = comminfo.getoperationcost(closed, pprice_orig)
-            openedvalue = comminfo.getoperationcost(opened, price)
-
-            # default in m_pnl is MAXFLOAT
-            pnl = cr.m_realizedPNL if closed else 0.0
-
-            # The internal broker calc should yield the same result
-            # pnl = comminfo.profitandloss(-closed, pprice_orig, price)
-
-            # Use the actual time provided by the execution object
-            # The report from TWS is in actual local time, not the data's tz
-            dt = date2num(datetime.strptime(ex.m_time, '%Y%m%d  %H:%M:%S'))
-
-            # Need to simulate a margin, but it plays no role, because it is
-            # controlled by a real broker. Let's set the price of the item
-            margin = order.data.close[0]
-
-            order.execute(dt, size, price,
-                          closed, closedvalue, closedcomm,
-                          opened, openedvalue, openedcomm,
-                          margin, pnl,
-                          psize, pprice)
-
-            if ostatus.status == self.FILLED:
-                order.completed()
-                self.ordstatus.pop(oid)  # nothing left to be reported
-            else:
-                order.partial()
-
-            if oid not in self.tonotify:  # Lock needed
-                self.tonotify.append(oid)
-
-    def push_portupdate(self):
-        # If the IBStore receives a Portfolio update, then this method will be
-        # indicated. If the execution of an order is split in serveral lots,
-        # updatePortfolio messages will be intermixed, which is used as a
-        # signal to indicate that the strategy can be notified
-        with self._lock_orders:
-            while self.tonotify:
-                oid = self.tonotify.popleft()
-                order = self.orderbyid[oid]
-                self.notify(order)
-
-    def push_ordererror(self, msg):
-        with self._lock_orders:
-            try:
-                order = self.orderbyid[msg.id]
-            except (KeyError, AttributeError):
-                return  # no order or no id in error
-
-            if msg.errorCode == 202:
-                if not order.alive():
-                    return
-                order.cancel()
-
-            elif msg.errorCode == 201:  # rejected
-                if order.status == order.Rejected:
-                    return
-                order.reject()
-
-            else:
-                order.reject()  # default for all other cases
-
-            self.notify(order)
-
-    def push_orderstate(self, msg):
-        with self._lock_orders:
-            try:
-                order = self.orderbyid[msg.orderId]
-            except (KeyError, AttributeError):
-                return  # no order or no id in error
-
-            if msg.orderState.m_status in ['PendingCancel', 'Cancelled',
-                                           'Canceled']:
-                # This is most likely due to an expiration]
-                order._willexpire = True
diff --git a/spaces/Lianjd/stock_dashboard/backtrader/observers/timereturn.py b/spaces/Lianjd/stock_dashboard/backtrader/observers/timereturn.py
deleted file mode 100644
index 248fb6be2bd574f84e4317078a703777f2bd4ba1..0000000000000000000000000000000000000000
--- a/spaces/Lianjd/stock_dashboard/backtrader/observers/timereturn.py
+++ /dev/null
@@ -1,89 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8; py-indent-offset:4 -*-
-###############################################################################
-#
-# Copyright (C) 2015-2020 Daniel Rodriguez
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-###############################################################################
-from __future__ import (absolute_import, division, print_function,
-                        unicode_literals)
-
-import calendar
-import datetime
-
-import backtrader as bt
-from .. import Observer, TimeFrame
-
-from backtrader.utils.py3 import MAXINT
-
-
-class TimeReturn(Observer):
-    '''This observer stores the *returns* of the strategy.
-
-    Params:
-
-      - ``timeframe`` (default: ``None``)
-        If ``None`` then the complete return over the entire backtested period
-        will be reported
-
-        Pass ``TimeFrame.NoTimeFrame`` to consider the entire dataset with no
-        time constraints
-
-      - ``compression`` (default: ``None``)
-
-        Only used for sub-day timeframes to for example work on an hourly
-        timeframe by specifying "TimeFrame.Minutes" and 60 as compression
-
-      - ``fund`` (default: ``None``)
-
-        If ``None`` the actual mode of the broker (fundmode - True/False) will
-        be autodetected to decide if the returns are based on the total net
-        asset value or on the fund value. See ``set_fundmode`` in the broker
-        documentation
-
-        Set it to ``True`` or ``False`` for a specific behavior
-
-    Remember that at any moment of a ``run`` the current values can be checked
-    by looking at the *lines* by name at index ``0``.
-
-    '''
-    _stclock = True
-
-    lines = ('timereturn',)
-    plotinfo = dict(plot=True, subplot=True)
-    plotlines = dict(timereturn=dict(_name='Return'))
-
-    params = (
-        ('timeframe', None),
-        ('compression', None),
-        ('fund', None),
-    )
-
-    def _plotlabel(self):
-        return [
-            # Use the final tf/comp values calculated by the return analyzer
-            TimeFrame.getname(self.treturn.timeframe,
-                              self.treturn.compression),
-            str(self.treturn.compression)
-        ]
-
-    def __init__(self):
-        self.treturn = self._owner._addanalyzer_slave(bt.analyzers.TimeReturn,
-                                                      **self.p._getkwargs())
-
-    def next(self):
-        self.lines.timereturn[0] = self.treturn.rets.get(self.treturn.dtkey,
-                                                         float('NaN'))
diff --git a/spaces/ML701G7/taim-gan/src/test_project/__init__.py b/spaces/ML701G7/taim-gan/src/test_project/__init__.py
deleted file mode 100644
index c98d66d286846041b80647bebc9c7c82b5bc7bcf..0000000000000000000000000000000000000000
--- a/spaces/ML701G7/taim-gan/src/test_project/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-"""test project imports"""
-from src.test_project.example import Foo
diff --git a/spaces/Marshalls/testmtd/analysis/aistplusplus_api/smpl/smpl_webuser/verts.py b/spaces/Marshalls/testmtd/analysis/aistplusplus_api/smpl/smpl_webuser/verts.py
deleted file mode 100644
index 330f48117388d8411c6f0b489e4aa6ff8b82c788..0000000000000000000000000000000000000000
--- a/spaces/Marshalls/testmtd/analysis/aistplusplus_api/smpl/smpl_webuser/verts.py
+++ /dev/null
@@ -1,103 +0,0 @@
-'''
-Copyright 2015 Matthew Loper, Naureen Mahmood and the Max Planck Gesellschaft.  All rights reserved.
-This software is provided for research purposes only.
-By using this software you agree to the terms of the SMPL Model license here http://smpl.is.tue.mpg.de/license
-
-More information about SMPL is available here http://smpl.is.tue.mpg.
-For comments or questions, please email us at: smpl@tuebingen.mpg.de
-
-
-About this file:
-================
-This file defines the basic skinning modules for the SMPL loader which 
-defines the effect of bones and blendshapes on the vertices of the template mesh.
-
-Modules included:
-- verts_decorated: 
-  creates an instance of the SMPL model which inherits model attributes from another 
-  SMPL model.
-- verts_core: [overloaded function inherited by lbs.verts_core]
-  computes the blending of joint-influences for each vertex based on type of skinning
-
-'''
-
-import chumpy
-import lbs
-from posemapper import posemap
-import scipy.sparse as sp
-from chumpy.ch import MatVecMult
-
-def ischumpy(x): return hasattr(x, 'dterms')
-
-def verts_decorated(trans, pose, 
-    v_template, J, weights, kintree_table, bs_style, f,
-    bs_type=None, posedirs=None, betas=None, shapedirs=None, want_Jtr=False):
-
-    for which in [trans, pose, v_template, weights, posedirs, betas, shapedirs]:
-        if which is not None:
-            assert ischumpy(which)
-
-    v = v_template
-
-    if shapedirs is not None:
-        if betas is None:
-            betas = chumpy.zeros(shapedirs.shape[-1])
-        v_shaped = v + shapedirs.dot(betas)
-    else:
-        v_shaped = v
-        
-    if posedirs is not None:
-        v_posed = v_shaped + posedirs.dot(posemap(bs_type)(pose))
-    else:
-        v_posed = v_shaped
-        
-    v = v_posed
-        
-    if sp.issparse(J):
-        regressor = J
-        J_tmpx = MatVecMult(regressor, v_shaped[:,0])        
-        J_tmpy = MatVecMult(regressor, v_shaped[:,1])        
-        J_tmpz = MatVecMult(regressor, v_shaped[:,2])        
-        J = chumpy.vstack((J_tmpx, J_tmpy, J_tmpz)).T            
-    else:    
-        assert(ischumpy(J))
-        
-    assert(bs_style=='lbs')
-    result, Jtr = lbs.verts_core(pose, v, J, weights, kintree_table, want_Jtr=True, xp=chumpy)
-     
-    tr = trans.reshape((1,3))
-    result = result + tr
-    Jtr = Jtr + tr
-
-    result.trans = trans
-    result.f = f
-    result.pose = pose
-    result.v_template = v_template
-    result.J = J
-    result.weights = weights
-    result.kintree_table = kintree_table
-    result.bs_style = bs_style
-    result.bs_type =bs_type
-    if posedirs is not None:
-        result.posedirs = posedirs
-        result.v_posed = v_posed
-    if shapedirs is not None:
-        result.shapedirs = shapedirs
-        result.betas = betas
-        result.v_shaped = v_shaped
-    if want_Jtr:
-        result.J_transformed = Jtr
-    return result
-
-def verts_core(pose, v, J, weights, kintree_table, bs_style, want_Jtr=False, xp=chumpy):
-    
-    if xp == chumpy:
-        assert(hasattr(pose, 'dterms'))
-        assert(hasattr(v, 'dterms'))
-        assert(hasattr(J, 'dterms'))
-        assert(hasattr(weights, 'dterms'))
-     
-    assert(bs_style=='lbs')
-    result = lbs.verts_core(pose, v, J, weights, kintree_table, want_Jtr, xp)
-
-    return result
diff --git a/spaces/Matthew1917/text_generator/app.py b/spaces/Matthew1917/text_generator/app.py
deleted file mode 100644
index 1ce98f235614530ad3143774fd7dea8072b4e96e..0000000000000000000000000000000000000000
--- a/spaces/Matthew1917/text_generator/app.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import gradio as gr
-from gradio.mix import Parallel
-
-titl="Doing magic"
-desc="Generate now"
-
-model1 = gr.Interface.load("huggingface/gpt2")
-model2 = gr.Interface.load("huggingface/EleutherAI/gpt-j-6B")
-model3 = gr.Interface.load("huggingface/EleutherAI/gpt-neo-1.3B")
-
-gr.Parallel(model1, model2, model3, title=titl, description=desc).launch()
\ No newline at end of file
diff --git a/spaces/MirageML/sjc/my/config.py b/spaces/MirageML/sjc/my/config.py
deleted file mode 100644
index 67af8cbeccc0cce7a6f128b60ab69d9a1127b737..0000000000000000000000000000000000000000
--- a/spaces/MirageML/sjc/my/config.py
+++ /dev/null
@@ -1,234 +0,0 @@
-from typing import List, Union
-from copy import deepcopy
-from collections import namedtuple
-from pathlib import Path
-import argparse
-from argparse import RawDescriptionHelpFormatter
-import yaml
-from pydantic import BaseModel as _Base
-
-
-class BaseConf(_Base):
-    class Config:
-        validate_all = True
-        allow_mutation = True
-        extra = "ignore"
-
-
-def SingleOrList(inner_type):
-    return Union[inner_type, List[inner_type]]
-
-
-def optional_load_config(fname="config.yml"):
-    cfg = {}
-    conf_fname = Path.cwd() / fname
-    if conf_fname.is_file():
-        with conf_fname.open("r") as f:
-            raw = f.read()
-            print("loaded config\n ")
-            print(raw)  # yaml raw itself is well formatted
-            cfg = yaml.safe_load(raw)
-    return cfg
-
-
-def write_full_config(cfg_obj, fname="full_config.yml"):
-    cfg = cfg_obj.dict()
-    cfg = _dict_to_yaml(cfg)
-    print(f"\n--- full config ---\n\n{cfg}\n")
-    with (Path.cwd() / fname).open("w") as f:
-        f.write(cfg)
-
-
-def argparse_cfg_template(curr_cfgs):
-    parser = argparse.ArgumentParser(
-        description='Manual spec of configs',
-        epilog=f'curr cfgs:\n\n{_dict_to_yaml(curr_cfgs)}',
-        formatter_class=RawDescriptionHelpFormatter
-    )
-    _, args = parser.parse_known_args()
-    clauses = []
-    for i in range(0, len(args), 2):
-        assert args[i][:2] == "--", "please start args with --"
-        clauses.append({args[i][2:]: args[i+1]})
-    print(f"cmdline clauses: {clauses}")
-
-    maker = ConfigMaker(curr_cfgs)
-    for clu in clauses:
-        maker.execute_clause(clu)
-
-    final = maker.state.copy()
-    return final
-
-
-def _dict_to_yaml(arg):
-    return yaml.safe_dump(arg, sort_keys=False, allow_unicode=True)
-
-
-def dispatch(module):
-    cfg = optional_load_config()
-    cfg = module(**cfg).dict()
-
-    cfg = argparse_cfg_template(cfg)  # cmdline takes priority
-    mod = module(**cfg)
-
-    write_full_config(mod)
-
-    mod.run()
-
-
-# below are some support tools
-
-
-class ConfigMaker():
-    CMD = namedtuple('cmd', field_names=['sub', 'verb', 'objs'])
-    VERBS = ('add', 'replace', 'del')
-
-    def __init__(self, base_node):
-        self.state = base_node
-        self.clauses = []
-
-    def clone(self):
-        return deepcopy(self)
-
-    def execute_clause(self, raw_clause):
-        cls = self.__class__
-        assert isinstance(raw_clause, (str, dict))
-        if isinstance(raw_clause, dict):
-            assert len(raw_clause) == 1, \
-                "a clause can only have 1 statement: {} clauses in {}".format(
-                    len(raw_clause), raw_clause
-            )
-            cmd = list(raw_clause.keys())[0]
-            arg = raw_clause[cmd]
-        else:
-            cmd = raw_clause
-            arg = None
-        cmd = self.parse_clause_cmd(cmd)
-        tracer = NodeTracer(self.state)
-        tracer.advance_pointer(path=cmd.sub)
-        if cmd.verb == cls.VERBS[0]:
-            tracer.add(cmd.objs, arg)
-        elif cmd.verb == cls.VERBS[1]:
-            tracer.replace(cmd.objs, arg)
-        elif cmd.verb == cls.VERBS[2]:
-            assert isinstance(raw_clause, str)
-            tracer.delete(cmd.objs)
-        self.state = tracer.state
-
-    @classmethod
-    def parse_clause_cmd(cls, input):
-        """
-        Args:
-            input: a string to be parsed
-        1. First test whether a verb is present
-        2. If not present, then str is a single subject, and verb is replace
-           This is a syntactical sugar that makes writing config easy
-        3. If a verb is found, whatever comes before is a subject, and after the
-           objects.
-        4. Handle the edge cases properly. Below are expected parse outputs
-        input       sub     verb        obj
-        --- No verb
-        ''          ''      replace     []
-        'a.b'       'a.b'   replace     []
-        'add'       ''      add         []
-        'P Q' err: 2 subjects
-        --- Verb present
-        'T add'     'T'     add         []
-        'T del a b' 'T'     del         [a, b]
-        'P Q add a' err: 2 subjects
-        'P add del b' err: 2 verbs
-        """
-        assert isinstance(input, str)
-        input = input.split()
-        objs = []
-        sub = ''
-        verb, verb_inx = cls.scan_for_verb(input)
-        if verb is None:
-            assert len(input) <= 1, "no verb present; more than 1 subject: {}"\
-                .format(input)
-            sub = input[0] if len(input) == 1 else ''
-            verb = cls.VERBS[1]
-        else:
-            assert not verb_inx > 1, 'verb {} at inx {}; more than 1 subject in: {}'\
-                .format(verb, verb_inx, input)
-            sub = input[0] if verb_inx == 1 else ''
-            objs = input[verb_inx + 1:]
-        cmd = cls.CMD(sub=sub, verb=verb, objs=objs)
-        return cmd
-
-    @classmethod
-    def scan_for_verb(cls, input_list):
-        assert isinstance(input_list, list)
-        counts = [ input_list.count(v) for v in cls.VERBS ]
-        presence = [ cnt > 0 for cnt in counts ]
-        if sum(presence) == 0:
-            return None, -1
-        elif sum(presence) > 1:
-            raise ValueError("multiple verbs discovered in {}".format(input_list))
-
-        if max(counts) > 1:
-            raise ValueError("verbs repeated in cmd: {}".format(input_list))
-        # by now, there is 1 verb that has occured exactly 1 time
-        verb = cls.VERBS[presence.index(1)]
-        inx = input_list.index(verb)
-        return verb, inx
-
-
-class NodeTracer():
-    def __init__(self, src_node):
-        """
-        A src node can be either a list or dict
-        """
-        assert isinstance(src_node, (list, dict))
-
-        # these are movable pointers
-        self.child_token = "_"  # init token can be anything
-        self.parent = {self.child_token: src_node}
-
-        # these are permanent pointers at the root
-        self.root_child_token = self.child_token
-        self.root = self.parent
-
-    @property
-    def state(self):
-        return self.root[self.root_child_token]
-
-    @property
-    def pointed(self):
-        return self.parent[self.child_token]
-
-    def advance_pointer(self, path):
-        if len(path) == 0:
-            return
-        path_list = list(
-            map(lambda x: int(x) if str.isdigit(x) else x, path.split('.'))
-        )
-
-        for i, token in enumerate(path_list):
-            self.parent = self.pointed
-            self.child_token = token
-            try:
-                self.pointed
-            except (IndexError, KeyError):
-                raise ValueError(
-                    "During the tracing of {}, {}-th token '{}'"
-                    " is not present in node {}".format(
-                        path, i, self.child_token, self.state
-                    )
-                )
-
-    def replace(self, objs, arg):
-        assert len(objs) == 0
-        val_type = type(self.parent[self.child_token])
-        # this is such an unfortunate hack
-        # turn everything to string, so that eval could work
-        # some of the clauses come from cmdline, some from yaml files for sow.
-        arg = str(arg)
-        if val_type == str:
-            pass
-        else:
-            arg = eval(arg)
-            assert type(arg) == val_type, \
-                f"require {val_type.__name__}, given {type(arg).__name__}"
-
-        self.parent[self.child_token] = arg
diff --git a/spaces/Miuzarte/SUI-svc-4.0/vdecoder/hifigan/env.py b/spaces/Miuzarte/SUI-svc-4.0/vdecoder/hifigan/env.py
deleted file mode 100644
index 2bdbc95d4f7a8bad8fd4f5eef657e2b51d946056..0000000000000000000000000000000000000000
--- a/spaces/Miuzarte/SUI-svc-4.0/vdecoder/hifigan/env.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import os
-import shutil
-
-
-class AttrDict(dict):
-    def __init__(self, *args, **kwargs):
-        super(AttrDict, self).__init__(*args, **kwargs)
-        self.__dict__ = self
-
-
-def build_env(config, config_name, path):
-    t_path = os.path.join(path, config_name)
-    if config != t_path:
-        os.makedirs(path, exist_ok=True)
-        shutil.copyfile(config, os.path.join(path, config_name))
diff --git a/spaces/Mountchicken/MAERec-Gradio/mmocr/models/textrecog/encoders/svtr_encoder.py b/spaces/Mountchicken/MAERec-Gradio/mmocr/models/textrecog/encoders/svtr_encoder.py
deleted file mode 100644
index aa27f42209c80fca9fdd58e1fae4566cbea9cc76..0000000000000000000000000000000000000000
--- a/spaces/Mountchicken/MAERec-Gradio/mmocr/models/textrecog/encoders/svtr_encoder.py
+++ /dev/null
@@ -1,639 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import Dict, List, Optional, Tuple, Union
-
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule
-from mmcv.cnn.bricks import DropPath
-from mmengine.model import BaseModule
-from mmengine.model.weight_init import trunc_normal_init
-
-from mmocr.registry import MODELS
-from mmocr.structures import TextRecogDataSample
-
-
-class OverlapPatchEmbed(BaseModule):
-    """Image to the progressive overlapping Patch Embedding.
-
-    Args:
-        in_channels (int): Number of input channels. Defaults to 3.
-        embed_dims (int): The dimensions of embedding. Defaults to 768.
-        num_layers (int, optional): Number of Conv_BN_Layer. Defaults to 2 and
-            limit to [2, 3].
-        init_cfg (dict or list[dict], optional): Initialization configs.
-            Defaults to None.
-    """
-
-    def __init__(self,
-                 in_channels: int = 3,
-                 embed_dims: int = 768,
-                 num_layers: int = 2,
-                 init_cfg: Optional[Union[Dict, List[Dict]]] = None):
-
-        super().__init__(init_cfg=init_cfg)
-
-        assert num_layers in [2, 3], \
-            'The number of layers must belong to [2, 3]'
-        self.net = nn.Sequential()
-        for num in range(num_layers, 0, -1):
-            if (num == num_layers):
-                _input = in_channels
-            _output = embed_dims // (2**(num - 1))
-            self.net.add_module(
-                f'ConvModule{str(num_layers - num)}',
-                ConvModule(
-                    in_channels=_input,
-                    out_channels=_output,
-                    kernel_size=3,
-                    stride=2,
-                    padding=1,
-                    norm_cfg=dict(type='BN'),
-                    act_cfg=dict(type='GELU')))
-            _input = _output
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward function.
-
-        Args:
-            x (Tensor): A Tensor of shape :math:`(N, C, H, W)`.
-
-        Returns:
-            Tensor: A tensor of shape math:`(N, HW//16, C)`.
-        """
-        x = self.net(x).flatten(2).permute(0, 2, 1)
-        return x
-
-
-class ConvMixer(BaseModule):
-    """The conv Mixer.
-
-    Args:
-        embed_dims (int): Number of character components.
-        num_heads (int, optional): Number of heads. Defaults to 8.
-        input_shape (Tuple[int, int], optional): The shape of input [H, W].
-            Defaults to [8, 25].
-        local_k (Tuple[int, int], optional): Window size. Defaults to [3, 3].
-        init_cfg (dict or list[dict], optional): Initialization configs.
-            Defaults to None.
-    """
-
-    def __init__(self,
-                 embed_dims: int,
-                 num_heads: int = 8,
-                 input_shape: Tuple[int, int] = [8, 25],
-                 local_k: Tuple[int, int] = [3, 3],
-                 init_cfg: Optional[Union[Dict, List[Dict]]] = None):
-        super().__init__(init_cfg)
-        self.input_shape = input_shape
-        self.embed_dims = embed_dims
-        self.local_mixer = nn.Conv2d(
-            in_channels=embed_dims,
-            out_channels=embed_dims,
-            kernel_size=local_k,
-            stride=1,
-            padding=(local_k[0] // 2, local_k[1] // 2),
-            groups=num_heads)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward function.
-
-        Args:
-            x (torch.Tensor): A Tensor of shape :math:`(N, HW, C)`.
-
-        Returns:
-            torch.Tensor: Tensor: A tensor of shape math:`(N, HW, C)`.
-        """
-        h, w = self.input_shape
-        x = x.permute(0, 2, 1).reshape([-1, self.embed_dims, h, w])
-        x = self.local_mixer(x)
-        x = x.flatten(2).permute(0, 2, 1)
-        return x
-
-
-class AttnMixer(BaseModule):
-    """One of mixer of {'Global', 'Local'}. Defaults to Global Mixer.
-
-    Args:
-        embed_dims (int): Number of character components.
-        num_heads (int, optional): Number of heads. Defaults to 8.
-        mixer (str, optional): The mixer type, choices are 'Global' and
-            'Local'. Defaults to 'Global'.
-        input_shape (Tuple[int, int], optional): The shape of input [H, W].
-            Defaults to [8, 25].
-        local_k (Tuple[int, int], optional): Window size. Defaults to [7, 11].
-        qkv_bias (bool, optional): Whether a additive bias is required.
-            Defaults to False.
-        qk_scale (float, optional): A scaling factor. Defaults to None.
-        attn_drop (float, optional): Attn dropout probability. Defaults to 0.0.
-        proj_drop (float, optional): Proj dropout layer. Defaults to 0.0.
-        init_cfg (dict or list[dict], optional): Initialization configs.
-            Defaults to None.
-    """
-
-    def __init__(self,
-                 embed_dims: int,
-                 num_heads: int = 8,
-                 mixer: str = 'Global',
-                 input_shape: Tuple[int, int] = [8, 25],
-                 local_k: Tuple[int, int] = [7, 11],
-                 qkv_bias: bool = False,
-                 qk_scale: float = None,
-                 attn_drop: float = 0.,
-                 proj_drop: float = 0.,
-                 init_cfg: Optional[Union[Dict, List[Dict]]] = None):
-        super().__init__(init_cfg)
-        assert mixer in {'Global', 'Local'}, \
-            "The type of mixer must belong to {'Global', 'Local'}"
-        self.num_heads = num_heads
-        head_dim = embed_dims // num_heads
-        self.scale = qk_scale or head_dim**-0.5
-        self.qkv = nn.Linear(embed_dims, embed_dims * 3, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(embed_dims, embed_dims)
-        self.proj_drop = nn.Dropout(proj_drop)
-        self.input_shape = input_shape
-        if input_shape is not None:
-            height, width = input_shape
-            self.input_size = height * width
-            self.embed_dims = embed_dims
-        if mixer == 'Local' and input_shape is not None:
-            hk = local_k[0]
-            wk = local_k[1]
-            mask = torch.ones(
-                [height * width, height + hk - 1, width + wk - 1],
-                dtype=torch.float32)
-            for h in range(0, height):
-                for w in range(0, width):
-                    mask[h * width + w, h:h + hk, w:w + wk] = 0.
-            mask = mask[:, hk // 2:height + hk // 2,
-                        wk // 2:width + wk // 2].flatten(1)
-            mask[mask >= 1] = -np.inf
-            self.register_buffer('mask', mask[None, None, :, :])
-        self.mixer = mixer
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward function.
-
-        Args:
-            x (torch.Tensor): A Tensor of shape :math:`(N, H, W, C)`.
-
-        Returns:
-            torch.Tensor: A Tensor of shape :math:`(N, H, W, C)`.
-        """
-        if self.input_shape is not None:
-            input_size, embed_dims = self.input_size, self.embed_dims
-        else:
-            _, input_size, embed_dims = x.shape
-        qkv = self.qkv(x).reshape((-1, input_size, 3, self.num_heads,
-                                   embed_dims // self.num_heads)).permute(
-                                       (2, 0, 3, 1, 4))
-        q, k, v = qkv[0] * self.scale, qkv[1], qkv[2]
-        attn = q.matmul(k.permute(0, 1, 3, 2))
-        if self.mixer == 'Local':
-            attn += self.mask
-        attn = F.softmax(attn, dim=-1)
-        attn = self.attn_drop(attn)
-
-        x = attn.matmul(v).permute(0, 2, 1, 3).reshape(-1, input_size,
-                                                       embed_dims)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x
-
-
-class MLP(BaseModule):
-    """The MLP block.
-
-    Args:
-        in_features (int): The input features.
-        hidden_features (int, optional): The hidden features.
-            Defaults to None.
-        out_features (int, optional): The output features.
-            Defaults to None.
-        drop (float, optional): cfg of dropout function. Defaults to 0.0.
-        init_cfg (dict or list[dict], optional): Initialization configs.
-            Defaults to None.
-    """
-
-    def __init__(self,
-                 in_features: int,
-                 hidden_features: int = None,
-                 out_features: int = None,
-                 drop: float = 0.,
-                 init_cfg: Optional[Union[Dict, List[Dict]]] = None):
-        super().__init__(init_cfg)
-        hidden_features = hidden_features or in_features
-        out_features = out_features or in_features
-        self.fc1 = nn.Linear(in_features, hidden_features)
-        self.act = nn.GELU()
-        self.fc2 = nn.Linear(hidden_features, out_features)
-        self.drop = nn.Dropout(drop)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward function.
-
-        Args:
-            x (torch.Tensor): A Tensor of shape :math:`(N, H, W, C)`.
-
-        Returns:
-            torch.Tensor: A Tensor of shape :math:`(N, H, W, C)`.
-        """
-        x = self.fc1(x)
-        x = self.act(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        x = self.drop(x)
-        return x
-
-
-class MixingBlock(BaseModule):
-    """The Mixing block.
-
-    Args:
-        embed_dims (int): Number of character components.
-        num_heads (int): Number of heads
-        mixer (str, optional): The mixer type. Defaults to 'Global'.
-        window_size (Tuple[int ,int], optional): Local window size.
-            Defaults to [7, 11].
-        input_shape (Tuple[int, int], optional): The shape of input [H, W].
-            Defaults to [8, 25].
-        mlp_ratio (float, optional): The ratio of hidden features to input.
-            Defaults to 4.0.
-        qkv_bias (bool, optional): Whether a additive bias is required.
-            Defaults to False.
-        qk_scale (float, optional): A scaling factor. Defaults to None.
-        drop (float, optional): cfg of Dropout. Defaults to 0..
-        attn_drop (float, optional): cfg of Dropout. Defaults to 0.0.
-        drop_path (float, optional): The probability of drop path.
-            Defaults to 0.0.
-        pernorm (bool, optional): Whether to place the MxingBlock before norm.
-            Defaults to True.
-        init_cfg (dict or list[dict], optional): Initialization configs.
-            Defaults to None.
-    """
-
-    def __init__(self,
-                 embed_dims: int,
-                 num_heads: int,
-                 mixer: str = 'Global',
-                 window_size: Tuple[int, int] = [7, 11],
-                 input_shape: Tuple[int, int] = [8, 25],
-                 mlp_ratio: float = 4.,
-                 qkv_bias: bool = False,
-                 qk_scale: float = None,
-                 drop: float = 0.,
-                 attn_drop: float = 0.,
-                 drop_path=0.,
-                 prenorm: bool = True,
-                 init_cfg: Optional[Union[Dict, List[Dict]]] = None):
-        super().__init__(init_cfg)
-        self.norm1 = nn.LayerNorm(embed_dims, eps=1e-6)
-        if mixer in {'Global', 'Local'}:
-            self.mixer = AttnMixer(
-                embed_dims,
-                num_heads=num_heads,
-                mixer=mixer,
-                input_shape=input_shape,
-                local_k=window_size,
-                qkv_bias=qkv_bias,
-                qk_scale=qk_scale,
-                attn_drop=attn_drop,
-                proj_drop=drop)
-        elif mixer == 'Conv':
-            self.mixer = ConvMixer(
-                embed_dims,
-                num_heads=num_heads,
-                input_shape=input_shape,
-                local_k=window_size)
-        else:
-            raise TypeError('The mixer must be one of [Global, Local, Conv]')
-        self.drop_path = DropPath(
-            drop_path) if drop_path > 0. else nn.Identity()
-        self.norm2 = nn.LayerNorm(embed_dims, eps=1e-6)
-        mlp_hidden_dim = int(embed_dims * mlp_ratio)
-        self.mlp_ratio = mlp_ratio
-        self.mlp = MLP(
-            in_features=embed_dims, hidden_features=mlp_hidden_dim, drop=drop)
-        self.prenorm = prenorm
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward function.
-
-        Args:
-            x (torch.Tensor): A Tensor of shape :math:`(N, H*W, C)`.
-
-        Returns:
-            torch.Tensor: A Tensor of shape :math:`(N, H*W, C)`.
-        """
-        if self.prenorm:
-            x = self.norm1(x + self.drop_path(self.mixer(x)))
-            x = self.norm2(x + self.drop_path(self.mlp(x)))
-        else:
-            x = x + self.drop_path(self.mixer(self.norm1(x)))
-            x = x + self.drop_path(self.mlp(self.norm2(x)))
-        return x
-
-
-class MerigingBlock(BaseModule):
-    """The last block of any stage, except for the last stage.
-
-    Args:
-        in_channels (int): The channels of input.
-        out_channels (int): The channels of output.
-        types (str, optional): Which downsample operation of ['Pool', 'Conv'].
-            Defaults to 'Pool'.
-        stride (Union[int, Tuple[int, int]], optional): Stride of the Conv.
-            Defaults to [2, 1].
-        act (bool, optional): activation function. Defaults to None.
-        init_cfg (dict or list[dict], optional): Initialization configs.
-            Defaults to None.
-    """
-
-    def __init__(self,
-                 in_channels: int,
-                 out_channels: int,
-                 types: str = 'Pool',
-                 stride: Union[int, Tuple[int, int]] = [2, 1],
-                 act: bool = None,
-                 init_cfg: Optional[Union[Dict, List[Dict]]] = None):
-        super().__init__(init_cfg)
-        self.types = types
-        if types == 'Pool':
-            self.avgpool = nn.AvgPool2d(
-                kernel_size=[3, 5], stride=stride, padding=[1, 2])
-            self.maxpool = nn.MaxPool2d(
-                kernel_size=[3, 5], stride=stride, padding=[1, 2])
-            self.proj = nn.Linear(in_channels, out_channels)
-        else:
-            self.conv = nn.Conv2d(
-                in_channels,
-                out_channels,
-                kernel_size=3,
-                stride=stride,
-                padding=1)
-        self.norm = nn.LayerNorm(out_channels)
-        if act is not None:
-            self.act = act()
-        else:
-            self.act = None
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward function.
-
-        Args:
-            x (torch.Tensor): A Tensor of shape :math:`(N, H, W, C)`.
-
-        Returns:
-            torch.Tensor: A Tensor of shape :math:`(N, H/2, W, 2C)`.
-        """
-        if self.types == 'Pool':
-            x = (self.avgpool(x) + self.maxpool(x)) * 0.5
-            out = self.proj(x.flatten(2).permute(0, 2, 1))
-
-        else:
-            x = self.conv(x)
-            out = x.flatten(2).permute(0, 2, 1)
-        out = self.norm(out)
-        if self.act is not None:
-            out = self.act(out)
-
-        return out
-
-
-@MODELS.register_module()
-class SVTREncoder(BaseModule):
-    """A PyTorch implementation of `SVTR: Scene Text Recognition with a Single
-    Visual Model <https://arxiv.org/abs/2205.00159>`_
-
-    Code is partially modified from https://github.com/PaddlePaddle/PaddleOCR.
-
-    Args:
-        img_size (Tuple[int, int], optional): The expected input image shape.
-            Defaults to [32, 100].
-        in_channels (int, optional): The num of input channels. Defaults to 3.
-        embed_dims (Tuple[int, int, int], optional): Number of input channels.
-            Defaults to [64, 128, 256].
-        depth (Tuple[int, int, int], optional):
-            The number of MixingBlock at each stage. Defaults to [3, 6, 3].
-        num_heads (Tuple[int, int, int], optional): Number of attention heads.
-            Defaults to [2, 4, 8].
-        mixer_types (Tuple[str], optional): Mixing type in a MixingBlock.
-            Defaults to ['Local']*6+['Global']*6.
-        window_size (Tuple[Tuple[int, int]], optional):
-            The height and width of the window at eeach stage.
-            Defaults to [[7, 11], [7, 11], [7, 11]].
-        merging_types (str, optional): The way of downsample in MergingBlock.
-            Defaults to 'Conv'.
-        mlp_ratio (int, optional): Ratio of hidden features to input in MLP.
-            Defaults to 4.
-        qkv_bias (bool, optional):
-            Whether to add bias for qkv in attention modules. Defaults to True.
-        qk_scale (float, optional): A scaling factor. Defaults to None.
-        drop_rate (float, optional): Probability of an element to be zeroed.
-            Defaults to 0.0.
-        last_drop (float, optional): cfg of dropout at last stage.
-            Defaults to 0.1.
-        attn_drop_rate (float, optional): _description_. Defaults to 0..
-        drop_path_rate (float, optional): stochastic depth rate.
-            Defaults to 0.1.
-        out_channels (int, optional): The num of output channels in backone.
-            Defaults to 192.
-        max_seq_len (int, optional): Maximum output sequence length :math:`T`.
-            Defaults to 25.
-        num_layers (int, optional): The num of conv in PatchEmbedding.
-            Defaults to 2.
-        prenorm (bool, optional): Whether to place the MixingBlock before norm.
-            Defaults to True.
-        init_cfg (dict or list[dict], optional): Initialization configs.
-            Defaults to None.
-    """
-
-    def __init__(self,
-                 img_size: Tuple[int, int] = [32, 100],
-                 in_channels: int = 3,
-                 embed_dims: Tuple[int, int, int] = [64, 128, 256],
-                 depth: Tuple[int, int, int] = [3, 6, 3],
-                 num_heads: Tuple[int, int, int] = [2, 4, 8],
-                 mixer_types: Tuple[str] = ['Local'] * 6 + ['Global'] * 6,
-                 window_size: Tuple[Tuple[int, int]] = [[7, 11], [7, 11],
-                                                        [7, 11]],
-                 merging_types: str = 'Conv',
-                 mlp_ratio: int = 4,
-                 qkv_bias: bool = True,
-                 qk_scale: float = None,
-                 drop_rate: float = 0.,
-                 last_drop: float = 0.1,
-                 attn_drop_rate: float = 0.,
-                 drop_path_rate: float = 0.1,
-                 out_channels: int = 192,
-                 max_seq_len: int = 25,
-                 num_layers: int = 2,
-                 prenorm: bool = True,
-                 init_cfg: Optional[Union[Dict, List[Dict]]] = None):
-        super().__init__(init_cfg)
-        self.img_size = img_size
-        self.embed_dims = embed_dims
-        self.out_channels = out_channels
-        self.prenorm = prenorm
-        self.patch_embed = OverlapPatchEmbed(
-            in_channels=in_channels,
-            embed_dims=embed_dims[0],
-            num_layers=num_layers)
-        num_patches = (img_size[1] // (2**num_layers)) * (
-            img_size[0] // (2**num_layers))
-        self.input_shape = [
-            img_size[0] // (2**num_layers), img_size[1] // (2**num_layers)
-        ]
-        self.absolute_pos_embed = nn.Parameter(
-            torch.zeros([1, num_patches, embed_dims[0]], dtype=torch.float32),
-            requires_grad=True)
-        self.pos_drop = nn.Dropout(drop_rate)
-        dpr = np.linspace(0, drop_path_rate, sum(depth))
-
-        self.blocks1 = nn.ModuleList([
-            MixingBlock(
-                embed_dims=embed_dims[0],
-                num_heads=num_heads[0],
-                mixer=mixer_types[0:depth[0]][i],
-                window_size=window_size[0],
-                input_shape=self.input_shape,
-                mlp_ratio=mlp_ratio,
-                qkv_bias=qkv_bias,
-                qk_scale=qk_scale,
-                drop=drop_rate,
-                attn_drop=attn_drop_rate,
-                drop_path=dpr[0:depth[0]][i],
-                prenorm=prenorm) for i in range(depth[0])
-        ])
-        self.downsample1 = MerigingBlock(
-            in_channels=embed_dims[0],
-            out_channels=embed_dims[1],
-            types=merging_types,
-            stride=[2, 1])
-        input_shape = [self.input_shape[0] // 2, self.input_shape[1]]
-        self.merging_types = merging_types
-
-        self.blocks2 = nn.ModuleList([
-            MixingBlock(
-                embed_dims=embed_dims[1],
-                num_heads=num_heads[1],
-                mixer=mixer_types[depth[0]:depth[0] + depth[1]][i],
-                window_size=window_size[1],
-                input_shape=input_shape,
-                mlp_ratio=mlp_ratio,
-                qkv_bias=qkv_bias,
-                qk_scale=qk_scale,
-                drop=drop_rate,
-                attn_drop=attn_drop_rate,
-                drop_path=dpr[depth[0]:depth[0] + depth[1]][i],
-                prenorm=prenorm) for i in range(depth[1])
-        ])
-        self.downsample2 = MerigingBlock(
-            in_channels=embed_dims[1],
-            out_channels=embed_dims[2],
-            types=merging_types,
-            stride=[2, 1])
-        input_shape = [self.input_shape[0] // 4, self.input_shape[1]]
-
-        self.blocks3 = nn.ModuleList([
-            MixingBlock(
-                embed_dims=embed_dims[2],
-                num_heads=num_heads[2],
-                mixer=mixer_types[depth[0] + depth[1]:][i],
-                window_size=window_size[2],
-                input_shape=input_shape,
-                mlp_ratio=mlp_ratio,
-                qkv_bias=qkv_bias,
-                qk_scale=qk_scale,
-                drop=drop_rate,
-                attn_drop=attn_drop_rate,
-                drop_path=dpr[depth[0] + depth[1]:][i],
-                prenorm=prenorm) for i in range(depth[2])
-        ])
-        self.layer_norm = nn.LayerNorm(self.embed_dims[-1], eps=1e-6)
-        self.avgpool = nn.AdaptiveAvgPool2d([1, max_seq_len])
-        self.last_conv = nn.Conv2d(
-            in_channels=embed_dims[2],
-            out_channels=self.out_channels,
-            kernel_size=1,
-            bias=False,
-            stride=1,
-            padding=0)
-        self.hardwish = nn.Hardswish()
-        self.dropout = nn.Dropout(p=last_drop)
-
-        trunc_normal_init(self.absolute_pos_embed, mean=0, std=0.02)
-        self.apply(self._init_weights)
-
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_init(m.weight, mean=0, std=0.02)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.zeros_(m.bias)
-        if isinstance(m, nn.LayerNorm):
-            nn.init.zeros_(m.bias)
-            nn.init.ones_(m.weight)
-        if isinstance(m, nn.Conv2d):
-            nn.init.kaiming_normal_(
-                m.weight, mode='fan_out', nonlinearity='relu')
-
-    def forward_features(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward function except the last combing operation.
-
-        Args:
-            x (torch.Tensor): A Tensor of shape :math:`(N, H, W, C)`.
-
-        Returns:
-            torch.Tensor: A Tensor of shape :math:`(N, H/16, W/4, 256)`.
-        """
-        x = self.patch_embed(x)
-        x = x + self.absolute_pos_embed
-        x = self.pos_drop(x)
-        for blk in self.blocks1:
-            x = blk(x)
-        x = self.downsample1(
-            x.permute(0, 2, 1).reshape([
-                -1, self.embed_dims[0], self.input_shape[0],
-                self.input_shape[1]
-            ]))
-
-        for blk in self.blocks2:
-            x = blk(x)
-        x = self.downsample2(
-            x.permute(0, 2, 1).reshape([
-                -1, self.embed_dims[1], self.input_shape[0] // 2,
-                self.input_shape[1]
-            ]))
-
-        for blk in self.blocks3:
-            x = blk(x)
-        if not self.prenorm:
-            x = self.layer_norm(x)
-        return x
-
-    def forward(self,
-                x: torch.Tensor,
-                data_samples: List[TextRecogDataSample] = None
-                ) -> torch.Tensor:
-        """Forward function.
-
-        Args:
-            x (torch.Tensor): A Tensor of shape :math:`(N, H/16, W/4, 256)`.
-            data_samples (list[TextRecogDataSample]): Batch of
-                TextRecogDataSample. Defaults to None.
-
-        Returns:
-            torch.Tensor: A Tensor of shape :math:`(N, 1, W/4, 192)`.
-        """
-        x = self.forward_features(x)
-        x = self.avgpool(
-            x.permute(0, 2, 1).reshape([
-                -1, self.embed_dims[2], self.input_shape[0] // 4,
-                self.input_shape[1]
-            ]))
-        x = self.last_conv(x)
-        x = self.hardwish(x)
-        x = self.dropout(x)
-        return x
diff --git a/spaces/NAACL2022/CLIP-Caption-Reward/setup.py b/spaces/NAACL2022/CLIP-Caption-Reward/setup.py
deleted file mode 100644
index cda90a841a8e0bb31de777447548a7db05f6f078..0000000000000000000000000000000000000000
--- a/spaces/NAACL2022/CLIP-Caption-Reward/setup.py
+++ /dev/null
@@ -1,7 +0,0 @@
-import setuptools
-
-setuptools.setup(
-    name="captioning",
-    version="0.0.1",
-    packages=setuptools.find_packages(),
-)
\ No newline at end of file
diff --git a/spaces/NATSpeech/DiffSpeech/modules/commons/wavenet.py b/spaces/NATSpeech/DiffSpeech/modules/commons/wavenet.py
deleted file mode 100644
index 7809c9b9d3331ba4fd2ffd4caae14e721e4b0732..0000000000000000000000000000000000000000
--- a/spaces/NATSpeech/DiffSpeech/modules/commons/wavenet.py
+++ /dev/null
@@ -1,97 +0,0 @@
-import torch
-from torch import nn
-
-
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-    n_channels_int = n_channels[0]
-    in_act = input_a + input_b
-    t_act = torch.tanh(in_act[:, :n_channels_int, :])
-    s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-    acts = t_act * s_act
-    return acts
-
-
-class WN(torch.nn.Module):
-    def __init__(self, hidden_size, kernel_size, dilation_rate, n_layers, c_cond=0,
-                 p_dropout=0, share_cond_layers=False, is_BTC=False):
-        super(WN, self).__init__()
-        assert (kernel_size % 2 == 1)
-        assert (hidden_size % 2 == 0)
-        self.is_BTC = is_BTC
-        self.hidden_size = hidden_size
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.gin_channels = c_cond
-        self.p_dropout = p_dropout
-        self.share_cond_layers = share_cond_layers
-
-        self.in_layers = torch.nn.ModuleList()
-        self.res_skip_layers = torch.nn.ModuleList()
-        self.drop = nn.Dropout(p_dropout)
-
-        if c_cond != 0 and not share_cond_layers:
-            cond_layer = torch.nn.Conv1d(c_cond, 2 * hidden_size * n_layers, 1)
-            self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight')
-
-        for i in range(n_layers):
-            dilation = dilation_rate ** i
-            padding = int((kernel_size * dilation - dilation) / 2)
-            in_layer = torch.nn.Conv1d(hidden_size, 2 * hidden_size, kernel_size,
-                                       dilation=dilation, padding=padding)
-            in_layer = torch.nn.utils.weight_norm(in_layer, name='weight')
-            self.in_layers.append(in_layer)
-
-            # last one is not necessary
-            if i < n_layers - 1:
-                res_skip_channels = 2 * hidden_size
-            else:
-                res_skip_channels = hidden_size
-
-            res_skip_layer = torch.nn.Conv1d(hidden_size, res_skip_channels, 1)
-            res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight')
-            self.res_skip_layers.append(res_skip_layer)
-
-    def forward(self, x, nonpadding=None, cond=None):
-        if self.is_BTC:
-            x = x.transpose(1, 2)
-            cond = cond.transpose(1, 2) if cond is not None else None
-            nonpadding = nonpadding.transpose(1, 2) if nonpadding is not None else None
-        if nonpadding is None:
-            nonpadding = 1
-        output = torch.zeros_like(x)
-        n_channels_tensor = torch.IntTensor([self.hidden_size])
-
-        if cond is not None and not self.share_cond_layers:
-            cond = self.cond_layer(cond)
-
-        for i in range(self.n_layers):
-            x_in = self.in_layers[i](x)
-            x_in = self.drop(x_in)
-            if cond is not None:
-                cond_offset = i * 2 * self.hidden_size
-                cond_l = cond[:, cond_offset:cond_offset + 2 * self.hidden_size, :]
-            else:
-                cond_l = torch.zeros_like(x_in)
-
-            acts = fused_add_tanh_sigmoid_multiply(x_in, cond_l, n_channels_tensor)
-
-            res_skip_acts = self.res_skip_layers[i](acts)
-            if i < self.n_layers - 1:
-                x = (x + res_skip_acts[:, :self.hidden_size, :]) * nonpadding
-                output = output + res_skip_acts[:, self.hidden_size:, :]
-            else:
-                output = output + res_skip_acts
-        output = output * nonpadding
-        if self.is_BTC:
-            output = output.transpose(1, 2)
-        return output
-
-    def remove_weight_norm(self):
-        def remove_weight_norm(m):
-            try:
-                nn.utils.remove_weight_norm(m)
-            except ValueError:  # this module didn't have weight norm
-                return
-
-        self.apply(remove_weight_norm)
diff --git a/spaces/NCTCMumbai/NCTC/models/official/nlp/xlnet/xlnet_modeling.py b/spaces/NCTCMumbai/NCTC/models/official/nlp/xlnet/xlnet_modeling.py
deleted file mode 100644
index 3e16af8e9930ba4dabb8e92743769cf1ebb48585..0000000000000000000000000000000000000000
--- a/spaces/NCTCMumbai/NCTC/models/official/nlp/xlnet/xlnet_modeling.py
+++ /dev/null
@@ -1,1290 +0,0 @@
-# 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.
-# ==============================================================================
-"""Keras layers of XLNet model in TF 2.0."""
-
-from __future__ import absolute_import
-from __future__ import division
-# from __future__ import google_type_annotations
-from __future__ import print_function
-
-import copy
-import numpy as np
-
-import tensorflow as tf
-from official.nlp.xlnet import data_utils
-
-
-def gelu(x):
-  """Gaussian Error Linear Unit.
-
-  This is a smoother version of the RELU.
-  Original paper: https://arxiv.org/abs/1606.08415
-  Args:
-    x: float Tensor to perform activation.
-
-  Returns:
-    `x` with the GELU activation applied.
-  """
-  cdf = 0.5 * (1.0 + tf.tanh(
-      (np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3)))))
-  return x * cdf
-
-
-def rel_shift(x, klen=-1):
-  """Performs relative shift to form the relative attention score."""
-  x_size = tf.shape(x)
-
-  x = tf.reshape(x, [x_size[1], x_size[0], x_size[2], x_size[3]])
-  x = tf.slice(x, [1, 0, 0, 0], [-1, -1, -1, -1])
-  x = tf.reshape(x, [x_size[0], x_size[1] - 1, x_size[2], x_size[3]])
-  x = tf.slice(x, [0, 0, 0, 0], [-1, klen, -1, -1])
-
-  return x
-
-
-def _get_initializer(flags):
-  """Get variable intializer."""
-  if flags.init_method == 'uniform':
-    initializer = tf.keras.initializers.RandomUniform(
-        minval=-flags.init_range, maxval=flags.init_range)
-  elif flags.init_method == 'normal':
-    initializer = tf.keras.initializers.RandomNormal(stddev=flags.init_std)
-  else:
-    raise ValueError('Initializer {} not supported'.format(flags.init_method))
-  return initializer
-
-
-def _create_mask(qlen, mlen, dtype=tf.float32, same_length=False):
-  """Creates attention mask when single-side context allowed only."""
-  attn_mask = tf.ones([qlen, qlen], dtype=dtype)
-  mask_u = tf.linalg.band_part(attn_mask, 0, -1)
-  mask_dia = tf.linalg.band_part(attn_mask, 0, 0)
-  attn_mask_pad = tf.zeros([qlen, mlen], dtype=dtype)
-  ret = tf.concat([attn_mask_pad, mask_u - mask_dia], 1)
-  if same_length:
-    mask_l = tf.linalg.band_part(attn_mask, -1, 0)
-    ret = tf.concat([ret[:, :qlen] + mask_l - mask_dia, ret[:, qlen:]], 1)
-
-  return ret
-
-
-def _cache_mem(curr_out, prev_mem, mem_len, reuse_len=None):
-  """cache hidden states into memory."""
-
-  if mem_len is None or mem_len == 0:
-    return None
-  else:
-    if reuse_len is not None and reuse_len > 0:
-      curr_out = curr_out[:reuse_len]
-
-    if prev_mem is None:
-      new_mem = curr_out[-mem_len:]
-    else:
-      new_mem = tf.concat([prev_mem, curr_out], 0)[-mem_len:]
-
-  return tf.keras.backend.stop_gradient(new_mem)
-
-
-def is_special_none_tensor(tensor):
-  """Checks if a tensor is a special None Tensor."""
-  return tensor.shape.ndims == 0 and tensor.dtype == tf.int32
-
-
-class PositionalEmbedding(tf.keras.layers.Layer):
-  """Generates relative positional embeddings used in Transformer-XL and XLNet."""
-
-  def __init__(self, dim, **kwargs):
-    super(PositionalEmbedding, self).__init__(**kwargs)
-    self.dim = dim
-
-  def build(self, unused_input_shapes):
-    """Constructs inversed frequency vector for positional embedding layer."""
-    self.inv_freq = 1.0 / (10000.0**(tf.range(0, self.dim, 2.0) / self.dim))
-    super(PositionalEmbedding, self).build(unused_input_shapes)
-
-  def call(self, pos_seq, batch_size):
-    """Implements call() for the layer."""
-    sinusoid_inp = tf.einsum('i,d->id', pos_seq, self.inv_freq)
-    pos_emb = tf.concat([tf.sin(sinusoid_inp), tf.cos(sinusoid_inp)], -1)
-    pos_emb = pos_emb[:, None, :]
-
-    if batch_size is not None:
-      pos_emb = tf.tile(pos_emb, [1, batch_size, 1])
-
-    return pos_emb
-
-
-class RelativeAttention(tf.keras.layers.Layer):
-  """Core calculations for relative attention."""
-
-  def __init__(self, dropout_att, scale):
-    super(RelativeAttention, self).__init__()
-    self.scale = scale
-    self.dropout_att = dropout_att
-
-  def build(self, unused_input_shapes):
-    """Implements build() for the layer."""
-
-    self.attention_probs_dropout = tf.keras.layers.Dropout(
-        rate=self.dropout_att)
-
-    super(RelativeAttention, self).build(unused_input_shapes)
-
-  def call(self, q_head, k_head_h, v_head_h, k_head_r, seg_embed, seg_mat,
-           r_w_bias, r_r_bias, r_s_bias, attn_mask):
-    """Implements call() for the layer."""
-
-    # content based attention score
-    ac = tf.einsum('ibnd,jbnd->ijbn', q_head + r_w_bias, k_head_h)
-
-    # position based attention score
-    bd = tf.einsum('ibnd,jbnd->ijbn', q_head + r_r_bias, k_head_r)
-    bd = rel_shift(bd, klen=tf.shape(ac)[1])
-
-    # segment-based attention score
-    if seg_mat is None:
-      ef = 0
-    else:
-      ef = tf.einsum('ibnd,snd->isbn', q_head + r_s_bias, seg_embed)
-      tgt_shape = tf.shape(bd)
-      ef = tf.where(
-          tf.broadcast_to(tf.expand_dims(seg_mat, 3), tgt_shape),
-          tf.broadcast_to(ef[:, 1:, :, :], tgt_shape),
-          tf.broadcast_to(ef[:, :1, :, :], tgt_shape))
-
-    # merges attention scores and performs masking
-    attn_score = (ac + bd + ef) * self.scale
-    if attn_mask is not None:
-      attn_score = attn_score - 1e30 * attn_mask
-
-    # attention probability
-    attn_prob = tf.nn.softmax(attn_score, 1)
-    attn_prob = self.attention_probs_dropout(attn_prob)
-
-    # attention output
-    attn_vec = tf.einsum('ijbn,jbnd->ibnd', attn_prob, v_head_h)
-
-    return attn_vec
-
-
-class PositionwiseFF(tf.keras.layers.Layer):
-  """Positionwise feed-forward layer."""
-
-  def __init__(self, d_model, d_inner, dropout, kernel_initializer,
-               activation_type, **kwargs):
-    super(PositionwiseFF, self).__init__(**kwargs)
-    self.d_model = d_model
-    self.d_inner = d_inner
-    self.dropout = dropout
-    self.activation_type = activation_type
-    self.kernel_initializer = kernel_initializer
-
-  def build(self, unused_input_shapes):
-    """Implements build() for the layer."""
-    if self.activation_type == 'relu':
-      activation = tf.nn.relu
-    elif self.activation_type == 'gelu':
-      activation = gelu
-    else:
-      raise (ValueError('Unsupported activation type {}'.format(
-          self.activation_type)))
-    self.inner_projection_layer = (
-        tf.keras.layers.Dense(
-            units=self.d_inner,
-            activation=activation,
-            kernel_initializer=self.kernel_initializer,
-            name='layer_1'))
-    self.output_projection_layer = (
-        tf.keras.layers.Dense(
-            units=self.d_model,
-            kernel_initializer=self.kernel_initializer,
-            name='layer_2'))
-    self.output_dropout = tf.keras.layers.Dropout(
-        rate=self.dropout, name='drop_2')
-    self.output_layer_norm = (
-        tf.keras.layers.LayerNormalization(
-            name='LayerNorm', axis=-1, epsilon=1e-12))
-    super(PositionwiseFF, self).build(unused_input_shapes)
-
-  def call(self, inp):
-    """Implements call() for the layer."""
-
-    output = self.inner_projection_layer(inp)
-    output = self.output_projection_layer(output)
-    output = self.output_dropout(output)
-    output = self.output_layer_norm(output + inp)
-    return output
-
-
-class EmbeddingLookup(tf.keras.layers.Layer):
-  """Looks up words embeddings for id tensor."""
-
-  def __init__(self, n_token, d_embed, initializer, **kwargs):
-    super(EmbeddingLookup, self).__init__(**kwargs)
-    self.n_token = n_token
-    self.d_embed = d_embed
-    self.initializer = initializer
-
-  def build(self, unused_input_shapes):
-    """Implements build() for the layer."""
-    self.lookup_table = self.add_weight(
-        'lookup_table',
-        shape=[self.n_token, self.d_embed],
-        initializer=self.initializer,
-        dtype=self.dtype)
-
-    super(EmbeddingLookup, self).build(unused_input_shapes)
-
-  def call(self, inputs):
-    return tf.nn.embedding_lookup(self.lookup_table, inputs)
-
-
-class RelativeMultiheadAttention(tf.keras.layers.Layer):
-  """Multi-head attention with relative embedding."""
-
-  def __init__(self, d_model, n_head, d_head, dropout, dropout_att,
-               kernel_initializer, **kwargs):
-    super(RelativeMultiheadAttention, self).__init__(**kwargs)
-    self.d_model = d_model
-    self.n_head = n_head
-    self.d_head = d_head
-    self.dropout = dropout
-    self.dropout_att = dropout_att
-    self.initializer = kernel_initializer
-
-  def build(self, unused_input_shapes):
-    """Implements build() for the layer."""
-    self.scale = 1.0 / (self.d_head**0.5)
-
-    self.output_layer_norm = tf.keras.layers.LayerNormalization(
-        name='LayerNorm', axis=-1, epsilon=1e-12)
-
-    self.kh_projection_layer = self.add_weight(
-        'k/kernel',
-        shape=[self.d_model, self.n_head, self.d_head],
-        initializer=self.initializer)
-    self.vh_projection_layer = self.add_weight(
-        'v/kernel',
-        shape=[self.d_model, self.n_head, self.d_head],
-        initializer=self.initializer)
-    self.kr_projection_layer = self.add_weight(
-        'r/kernel',
-        shape=[self.d_model, self.n_head, self.d_head],
-        initializer=self.initializer)
-    self.qh_projection_layer = self.add_weight(
-        'q/kernel',
-        shape=[self.d_model, self.n_head, self.d_head],
-        initializer=self.initializer)
-
-    self.relative_attention_layer = RelativeAttention(
-        dropout_att=self.dropout_att, scale=self.scale)
-
-    self.proj_o = self.add_weight(
-        'o/kernel',
-        shape=[self.d_model, self.n_head, self.d_head],
-        initializer=self.initializer)
-
-    self.attention_dropout = tf.keras.layers.Dropout(rate=self.dropout)
-
-    super(RelativeMultiheadAttention, self).build(unused_input_shapes)
-
-  def call(self, h, g, r, r_w_bias, r_r_bias, seg_mat, r_s_bias, seg_embed,
-           attn_mask_h, attn_mask_g, mems, target_mapping):
-    """Implements call() for the layer."""
-
-    if mems is not None and mems.shape.ndims > 1:
-      cat = tf.concat([mems, h], 0)
-    else:
-      cat = h
-
-    # content heads
-    q_head_h = tf.einsum('ibh,hnd->ibnd', h, self.qh_projection_layer)
-    k_head_h = tf.einsum('ibh,hnd->ibnd', cat, self.kh_projection_layer)
-    v_head_h = tf.einsum('ibh,hnd->ibnd', cat, self.vh_projection_layer)
-
-    # positional heads
-    k_head_r = tf.einsum('ibh,hnd->ibnd', r, self.kr_projection_layer)
-
-    # core attention ops
-    attn_vec_h = self.relative_attention_layer(q_head_h, k_head_h, v_head_h,
-                                               k_head_r, seg_embed, seg_mat,
-                                               r_w_bias, r_r_bias, r_s_bias,
-                                               attn_mask_h)
-
-    # post processing
-    output_h = tf.einsum('ibnd,hnd->ibh', attn_vec_h, self.proj_o)
-    output_h = self.attention_dropout(output_h)
-    output_h = self.output_layer_norm(output_h + h)
-
-    output_g = None
-    if g is not None:  # enable two-stream attention
-      # g-stream
-      q_head_g = tf.einsum('ibh,hnd->ibnd', g, self.qh_projection_layer)
-      if target_mapping is not None:
-        q_head_g = tf.einsum('mbnd,mlb->lbnd', q_head_g, target_mapping)
-        attn_vec_g = self.relative_attention_layer(q_head_g, k_head_h, v_head_h,
-                                                   k_head_r, seg_embed, seg_mat,
-                                                   r_w_bias, r_r_bias, r_s_bias,
-                                                   attn_mask_g)
-        attn_vec_g = tf.einsum('lbnd,mlb->mbnd', attn_vec_g, target_mapping)
-
-      else:
-        attn_vec_g = self.relative_attention_layer(q_head_g, k_head_h, v_head_h,
-                                                   k_head_r, seg_embed, seg_mat,
-                                                   r_w_bias, r_r_bias, r_s_bias,
-                                                   attn_mask_g)
-
-      # post processing
-      output_g = tf.einsum('ibnd,hnd->ibh', attn_vec_g, self.proj_o)
-      output_g = self.attention_dropout(output_g)
-      output_g = self.output_layer_norm(output_g + g)
-
-    return (output_h, output_g)
-
-
-class TransformerXLModel(tf.keras.layers.Layer):
-  """Defines a Transformer-XL computation graph with additional support for XLNet."""
-
-  def __init__(self,
-               n_token,
-               n_layer,
-               d_model,
-               n_head,
-               d_head,
-               d_inner,
-               dropout,
-               dropout_att,
-               attn_type,
-               bi_data,
-               is_training,
-               initializer,
-               mem_len=None,
-               same_length=False,
-               clamp_len=-1,
-               untie_r=False,
-               use_tpu=True,
-               reuse_len=None,
-               ff_activation='relu',
-               use_cls_mask=False,
-               **kwargs):
-    """Initializes TransformerXLModel.
-
-    Args:
-      n_token: int, the number of tokens in vocabulary.
-      n_layer: int, the number of layers.
-      d_model: int, the hidden size.
-      n_head: int, the number of attention heads.
-      d_head: int, the dimension size of each attention head.
-      d_inner: int, the hidden size in feed-forward layers.
-      dropout: float, dropout rate.
-      dropout_att: float, dropout rate on attention probabilities.
-      attn_type: str, "uni" or "bi".
-      bi_data: bool, whether to use bidirectional input pipeline. Usually set to
-        True during pretraining and False during finetuning.
-      is_training: bool, whether in training mode.
-      initializer: A tf initializer.
-      mem_len: int, the number of tokens to cache.
-      same_length: bool, whether to use the same attention length for each
-        token.
-      clamp_len: int, clamp all relative distances larger than clamp_len. -1
-        means no clamping.
-      untie_r: bool, whether to untie the biases in attention.
-      use_tpu: bool, whether TPUs are used.
-      reuse_len: int, the number of tokens in the currect batch to be cached and
-        reused in the future.
-      ff_activation: str, "relu" or "gelu".
-      use_cls_mask: bool, whether to introduce cls mask.
-      **kwargs: Other parameters.
-    """
-
-    super(TransformerXLModel, self).__init__(**kwargs)
-
-    self.n_token = n_token
-    self.initializer = initializer
-    self.attn_type = attn_type
-    self.n_layer = n_layer
-    self.d_model = d_model
-    self.n_head = n_head
-    self.d_head = d_head
-    self.d_inner = d_inner
-    self.ff_activation = ff_activation
-    self.untie_r = untie_r
-    self.use_tpu = use_tpu
-    self.dropout = dropout
-    self.dropout_att = dropout_att
-
-    self.mem_len = mem_len
-    self.reuse_len = reuse_len
-    self.bi_data = bi_data
-    self.clamp_len = clamp_len
-    self.same_length = same_length
-    self.use_cls_mask = use_cls_mask
-
-  def build(self, unused_input_shapes):
-    """Implements build() for the layer."""
-    self.tf_float = tf.float32
-
-    self.embedding_lookup = EmbeddingLookup(
-        n_token=self.n_token,
-        d_embed=self.d_model,
-        initializer=self.initializer,
-        dtype=self.tf_float,
-        name='word_embedding')
-
-    self.h_dropout = tf.keras.layers.Dropout(rate=self.dropout)
-    self.g_dropout = tf.keras.layers.Dropout(rate=self.dropout)
-
-    if self.untie_r:
-      self.r_w_bias = (
-          self.add_weight(
-              'r_w_bias',
-              shape=[self.n_layer, self.n_head, self.d_head],
-              dtype=self.tf_float,
-              initializer=self.initializer))
-      self.r_r_bias = (
-          self.add_weight(
-              'r_r_bias',
-              shape=[self.n_layer, self.n_head, self.d_head],
-              dtype=self.tf_float,
-              initializer=self.initializer))
-      self.r_s_bias = (
-          self.add_weight(
-              'r_s_bias',
-              shape=[self.n_layer, self.n_head, self.d_head],
-              dtype=self.tf_float,
-              initializer=self.initializer))
-    else:
-      self.r_w_bias = (
-          self.add_weight(
-              'r_w_bias',
-              shape=[self.n_head, self.d_head],
-              dtype=self.tf_float,
-              initializer=self.initializer))
-      self.r_r_bias = (
-          self.add_weight(
-              'r_r_bias',
-              shape=[self.n_head, self.d_head],
-              dtype=self.tf_float,
-              initializer=self.initializer))
-      self.r_s_bias = (
-          self.add_weight(
-              'r_s_bias', [self.n_head, self.d_head],
-              dtype=self.tf_float,
-              initializer=self.initializer))
-
-    self.seg_embed = self.add_weight(
-        'seg_embed', [self.n_layer, 2, self.n_head, self.d_head],
-        dtype=self.tf_float,
-        initializer=self.initializer)
-
-    self.mask_emb = self.add_weight(
-        'mask_emb/mask_emb', shape=[1, 1, self.d_model], dtype=self.tf_float)
-
-    self.emb_dropout = tf.keras.layers.Dropout(rate=self.dropout)
-    self.fwd_position_embedding = PositionalEmbedding(self.d_model)
-    self.bwd_position_embedding = PositionalEmbedding(self.d_model)
-
-    self.rel_multihead_layers = []
-    self.h_positionwise_ffn_layers = []
-    for i in range(self.n_layer):
-      self.rel_multihead_layers.append(
-          RelativeMultiheadAttention(
-              d_model=self.d_model,
-              dropout=self.dropout,
-              n_head=self.n_head,
-              d_head=self.d_head,
-              dropout_att=self.dropout_att,
-              kernel_initializer=self.initializer,
-              name='layer_%d/rel_attn' % (i)))
-      self.h_positionwise_ffn_layers.append(
-          PositionwiseFF(
-              d_model=self.d_model,
-              d_inner=self.d_inner,
-              dropout=self.dropout,
-              kernel_initializer=self.initializer,
-              activation_type=self.ff_activation,
-              name='layer_%d/ff' % (i)))
-
-    self.output_dropout = tf.keras.layers.Dropout(rate=self.dropout)
-
-    super(TransformerXLModel, self).build(unused_input_shapes)
-
-  def __call__(self,
-               inp_k,
-               seg_id=None,
-               input_mask=None,
-               mems=None,
-               perm_mask=None,
-               target_mapping=None,
-               inp_q=None,
-               **kwargs):
-    # Uses dict to feed inputs into call() in order to keep mems as a python
-    # list.
-    inputs = {
-        'inp_k': inp_k,
-        'seg_id': seg_id,
-        'input_mask': input_mask,
-        'mems': mems,
-        'perm_mask': perm_mask,
-        'target_mapping': target_mapping,
-        'inp_q': inp_q
-    }
-    return super(TransformerXLModel, self).__call__(inputs, **kwargs)
-
-  def call(self, inputs):
-    """Implements call() for the layer."""
-    inp_k = inputs['inp_k']
-    seg_id = inputs['seg_id']
-    input_mask = inputs['input_mask']
-    mems = inputs['mems']
-    perm_mask = inputs['perm_mask']
-    target_mapping = inputs['target_mapping']
-    inp_q = inputs['inp_q']
-
-    new_mems = []
-
-    bsz = tf.shape(inp_k)[1]
-
-    qlen = inp_k.shape.as_list()[0]
-
-    mlen = mems[0].shape.as_list()[0] if mems is not None else 0
-    klen = mlen + qlen
-
-    ##### Attention mask
-    # causal attention mask
-    if self.attn_type == 'uni':
-      attn_mask = _create_mask(qlen, mlen, self.tf_float, self.same_length)
-      # pylint: enable=protected-access
-      attn_mask = attn_mask[:, :, None, None]
-    elif self.attn_type == 'bi':
-      attn_mask = None
-    else:
-      raise ValueError('Unsupported attention type: {}'.format(self.attn_type))
-
-    # data mask: input mask & perm mask
-    if input_mask is not None and perm_mask is not None:
-      data_mask = input_mask[None] + perm_mask
-
-    elif input_mask is not None and perm_mask is None:
-      data_mask = input_mask[None]
-    elif input_mask is None and perm_mask is not None:
-      data_mask = perm_mask
-    else:
-      data_mask = None
-
-    if data_mask is not None:
-      # all mems can be attended to
-      mems_mask = tf.zeros([tf.shape(data_mask)[0], mlen, bsz],
-                           dtype=self.tf_float)
-      data_mask = tf.concat([mems_mask, data_mask], 1)
-      if attn_mask is None:
-        attn_mask = data_mask[:, :, :, None]
-      else:
-        attn_mask += data_mask[:, :, :, None]
-
-    if attn_mask is not None:
-      attn_mask = tf.cast(attn_mask > 0, dtype=self.tf_float)
-
-    if attn_mask is not None:
-      non_tgt_mask = -tf.eye(qlen, dtype=self.tf_float)
-      non_tgt_mask = tf.concat(
-          [tf.zeros([qlen, mlen], dtype=self.tf_float), non_tgt_mask], axis=-1)
-      non_tgt_mask = tf.cast(
-          (attn_mask + non_tgt_mask[:, :, None, None]) > 0, dtype=self.tf_float)
-    else:
-      non_tgt_mask = None
-
-    word_emb_k = self.embedding_lookup(inp_k)
-
-    if inp_q is not None:
-      if target_mapping is not None:
-        word_emb_q = tf.tile(self.mask_emb,
-                             [tf.shape(target_mapping)[0], bsz, 1])
-      else:
-        inp_q_ext = inp_q[:, :, None]
-        word_emb_q = inp_q_ext * self.mask_emb + (1 - inp_q_ext) * word_emb_k
-
-    output_h = self.h_dropout(word_emb_k)
-    output_g = None
-    if inp_q is not None:
-      output_g = self.g_dropout(word_emb_q)
-
-    ##### Segment embedding
-    if seg_id is not None:
-
-      # Convert `seg_id` to one-hot `seg_mat`
-
-      mem_pad = tf.zeros([mlen, bsz], dtype=tf.int32)
-
-      cat_id = tf.concat([mem_pad, seg_id], 0)
-
-      if self.use_cls_mask:
-        # `1` indicates not in the same segment [qlen x klen x bsz]
-        # seg_id: [qlen x bsz] & cat_id: [klen x bsz]
-        cls_mat = tf.logical_or(
-            tf.equal(seg_id, tf.constant([data_utils.SEG_ID_CLS]))[:, None],
-            tf.equal(cat_id, tf.constant([data_utils.SEG_ID_CLS]))[None, :])
-        seg_mat = tf.equal(seg_id[:, None], cat_id[None, :])
-        seg_mat = tf.logical_or(cls_mat, seg_mat)
-      else:
-        seg_mat = tf.logical_not(tf.equal(seg_id[:, None], cat_id[None, :]))
-    else:
-      seg_mat = None
-
-    dtype = self.tf_float
-    freq_seq = tf.range(0, self.d_model, 2.0)
-    if dtype is not None and dtype != tf.float32:
-      freq_seq = tf.cast(freq_seq, dtype=self.dtype)
-
-    if self.attn_type == 'bi':
-      beg, end = klen, -qlen
-    elif self.attn_type == 'uni':
-      beg, end = klen, -1
-    else:
-      raise ValueError('Unknown `attn_type` {}.'.format(self.attn_type))
-
-    if self.bi_data:
-      fwd_pos_seq = tf.range(beg, end, -1.0)
-      bwd_pos_seq = tf.range(-beg, -end, 1.0)
-
-      if dtype is not None and dtype != tf.float32:
-        fwd_pos_seq = tf.cast(fwd_pos_seq, dtype=dtype)
-        bwd_pos_seq = tf.cast(bwd_pos_seq, dtype=dtype)
-
-      if self.clamp_len > 0:
-        fwd_pos_seq = tf.clip_by_value(fwd_pos_seq, -self.clamp_len,
-                                       self.clamp_len)
-        bwd_pos_seq = tf.clip_by_value(bwd_pos_seq, -self.clamp_len,
-                                       self.clamp_len)
-
-      if bsz is not None:
-        fwd_pos_emb = self.fwd_position_embedding(fwd_pos_seq, bsz // 2)
-        bwd_pos_emb = self.bwd_position_embedding(bwd_pos_seq, bsz // 2)
-      else:
-        fwd_pos_emb = self.fwd_position_embedding(fwd_pos_seq, None)
-        bwd_pos_emb = self.bwd_position_embedding(bwd_pos_seq, None)
-
-      pos_emb = tf.concat([fwd_pos_emb, bwd_pos_emb], axis=1)
-    else:
-      fwd_pos_seq = tf.range(beg, end, -1.0)
-      if dtype is not None and dtype != tf.float32:
-        fwd_pos_seq = tf.cast(fwd_pos_seq, dtype=dtype)
-      if self.clamp_len > 0:
-        fwd_pos_seq = tf.clip_by_value(fwd_pos_seq, -self.clamp_len,
-                                       self.lamp_len)
-
-      pos_emb = self.fwd_position_embedding(fwd_pos_seq, bsz)
-
-    pos_emb = self.emb_dropout(pos_emb)
-
-    if mems is None:
-      mems = [None] * self.n_layer
-    for i in range(self.n_layer):
-      # cache new mems
-      new_mems.append(
-          _cache_mem(output_h, mems[i], self.mem_len, self.reuse_len))
-      # pylint: enable=protected-access
-
-      # segment bias
-      if seg_id is None:
-        r_s_bias_i = None
-        seg_embed_i = None
-      else:
-        r_s_bias_i = self.r_s_bias if not self.untie_r else self.r_s_bias[i]
-        seg_embed_i = self.seg_embed[i]
-
-      ffn_layer = self.h_positionwise_ffn_layers[i]
-      attention_layer = self.rel_multihead_layers[i]
-      output_h, output_g = attention_layer(
-          h=output_h,
-          g=output_g,
-          r=pos_emb,
-          r_w_bias=self.r_w_bias if not self.untie_r else self.r_w_bias[i],
-          r_r_bias=self.r_r_bias if not self.untie_r else self.r_r_bias[i],
-          seg_mat=seg_mat,
-          r_s_bias=r_s_bias_i,
-          seg_embed=seg_embed_i,
-          attn_mask_h=non_tgt_mask,
-          attn_mask_g=attn_mask,
-          mems=mems[i],
-          target_mapping=target_mapping)
-      output_h = ffn_layer(output_h)
-      if output_g is not None:
-        output_g = ffn_layer(output_g)
-
-    if inp_q is not None:
-      output = output_g
-    else:
-      output = output_h
-
-    return output, new_mems, None
-
-
-class PretrainingXLNetModel(tf.keras.Model):
-  """XLNet keras model combined with pretraining LM loss layer.
-
-  See the original paper: https://arxiv.org/pdf/1906.08237.pdf
-
-  """
-
-  def __init__(self, use_proj, xlnet_config, run_config, **kwargs):
-    super(PretrainingXLNetModel, self).__init__(**kwargs)
-    self.run_config = run_config
-    self.initializer = _get_initializer(run_config)
-    self.xlnet_config = copy.deepcopy(xlnet_config)
-
-    self.transformerxl_model = TransformerXLModel(
-        n_token=self.xlnet_config.n_token,
-        initializer=self.initializer,
-        attn_type='bi',
-        n_layer=self.xlnet_config.n_layer,
-        d_model=self.xlnet_config.d_model,
-        n_head=self.xlnet_config.n_head,
-        d_head=self.xlnet_config.d_head,
-        d_inner=self.xlnet_config.d_inner,
-        ff_activation=self.xlnet_config.ff_activation,
-        untie_r=self.xlnet_config.untie_r,
-        is_training=self.run_config.is_training,
-        use_tpu=self.run_config.use_tpu,
-        dropout=self.run_config.dropout,
-        dropout_att=self.run_config.dropout_att,
-        mem_len=self.run_config.mem_len,
-        reuse_len=self.run_config.reuse_len,
-        bi_data=self.run_config.bi_data,
-        clamp_len=self.run_config.clamp_len,
-        same_length=self.run_config.same_length,
-        use_cls_mask=self.run_config.use_cls_mask,
-        name='transformer')
-    self.lmloss_layer = LMLossLayer(
-        n_token=self.xlnet_config.n_token,
-        d_model=self.xlnet_config.d_model,
-        initializer=self.initializer,
-        tie_weight=True,
-        bi_data=self.run_config.bi_data,
-        use_tpu=self.run_config.use_tpu,
-        use_proj=use_proj,
-        name='lm_loss')
-
-  def call(self, features):
-    """Implements call() for the layer."""
-
-    input_ids = tf.transpose(features['input_k'], [1, 0])
-    inp_q = tf.transpose(features['input_q'], [1, 0])
-
-    seg_ids = tf.transpose(features['seg_id'], [1, 0])
-
-    perm_mask = tf.transpose(features['perm_mask'], [1, 2, 0])
-
-    target_mapping = tf.transpose(features['target_mapping'], [1, 2, 0])
-
-    # target for LM loss
-    target = tf.transpose(features['target'], [1, 0])
-
-    # target mask for LM loss
-    tgt_mask = tf.transpose(features['target_mask'], [1, 0])
-
-    mems = features.get('mems', None)
-
-    transformerxl_output, self.new_mems, self.lookup_table = self.transformerxl_model(
-        input_ids,
-        seg_id=seg_ids,
-        input_mask=None,
-        mems=mems,
-        perm_mask=perm_mask,
-        target_mapping=target_mapping,
-        inp_q=inp_q)
-    lm_loss, _ = self.lmloss_layer(
-        hidden=transformerxl_output,
-        target=target,
-        lookup_table=self.transformerxl_model.embedding_lookup.lookup_table,
-        target_mask=tgt_mask)
-    self.add_loss(lm_loss)
-    return self.new_mems, transformerxl_output
-
-
-class ClassificationXLNetModel(tf.keras.Model):
-  """XLNet keras model combined with classification loss layer.
-
-  See the original paper: https://arxiv.org/pdf/1906.08237.pdf
-
-  """
-
-  def __init__(self, xlnet_config, run_config, n_class, summary_type, **kwargs):
-    super(ClassificationXLNetModel, self).__init__(**kwargs)
-    self.run_config = run_config
-    self.initializer = _get_initializer(run_config)
-    self.xlnet_config = copy.deepcopy(xlnet_config)
-
-    self.transformerxl_model = TransformerXLModel(
-        n_token=self.xlnet_config.n_token,
-        initializer=self.initializer,
-        attn_type='bi',
-        n_layer=self.xlnet_config.n_layer,
-        d_model=self.xlnet_config.d_model,
-        n_head=self.xlnet_config.n_head,
-        d_head=self.xlnet_config.d_head,
-        d_inner=self.xlnet_config.d_inner,
-        ff_activation=self.xlnet_config.ff_activation,
-        untie_r=self.xlnet_config.untie_r,
-        is_training=self.run_config.is_training,
-        use_tpu=self.run_config.use_tpu,
-        dropout=self.run_config.dropout,
-        dropout_att=self.run_config.dropout_att,
-        mem_len=self.run_config.mem_len,
-        reuse_len=self.run_config.reuse_len,
-        bi_data=self.run_config.bi_data,
-        clamp_len=self.run_config.clamp_len,
-        same_length=self.run_config.same_length,
-        name='transformer')
-
-    self.summarization_layer = Summarization(
-        d_model=self.xlnet_config.d_model,
-        n_head=self.xlnet_config.n_head,
-        d_head=self.xlnet_config.d_head,
-        dropout=self.run_config.dropout,
-        dropout_att=self.run_config.dropout_att,
-        initializer=self.initializer,
-        use_proj=True,
-        summary_type=summary_type,
-        name='sequence_summary')
-
-    self.cl_loss_layer = ClassificationLossLayer(
-        n_class=n_class, initializer=self.initializer, name='classification')
-
-  def call(self, features):
-    """Implements call() for the layer."""
-    bsz_per_core = tf.shape(features['input_ids'])[0]
-
-    input_ids = tf.transpose(features['input_ids'], [1, 0])
-    seg_ids = tf.transpose(features['segment_ids'], [1, 0])
-    input_mask = tf.transpose(features['input_mask'], [1, 0])
-
-    label = tf.reshape(features['label_ids'], [bsz_per_core])
-
-    mems = features.get('mems', None)
-
-    transformerxl_output, new_mems, self.lookup_table = (
-        self.transformerxl_model(input_ids, seg_ids, input_mask, mems))
-
-    summary = self.summarization_layer(transformerxl_output)
-    per_example_loss, logits = self.cl_loss_layer(hidden=summary, labels=label)
-    self.add_loss(tf.keras.backend.mean(per_example_loss))
-    return new_mems, logits
-
-
-class LMLossLayer(tf.keras.layers.Layer):
-  """Layer computing cross entropy loss for language modeling."""
-
-  def __init__(self,
-               n_token,
-               d_model,
-               initializer,
-               tie_weight=False,
-               bi_data=True,
-               use_tpu=False,
-               use_proj=False,
-               **kwargs):
-    """Constructs LMLoss layer.
-
-    Args:
-      n_token: Number of tokens in vocabulary.
-      d_model: The dimension of model hidden state.
-      initializer: Initializer used for parameters.
-      tie_weight: Whether to share weights between embedding lookup layer and
-        next-token prediction layer.
-      bi_data: Whether to use bidirectional input pipeline. Usually set to True
-        during pretraining and False during finetuning.
-      use_tpu: bool, whether to use TPU.
-      use_proj: bool, whether to add a projection layer before LM prediction.
-      **kwargs: Other parameters.
-    """
-    super(LMLossLayer, self).__init__(**kwargs)
-    self.n_token = n_token
-    self.d_model = d_model
-    self.initializer = initializer
-
-    self.tie_weight = tie_weight
-    self.bi_data = bi_data
-    self.use_tpu = use_tpu
-    self.use_proj = use_proj
-
-  def build(self, unused_input_shapes):
-    """Implements build() for the layer."""
-    if self.use_proj:
-      self.proj_layer = tf.keras.layers.Dense(
-          units=self.d_model,
-          kernel_initializer=self.initializer,
-          activation=gelu,
-          name='lm_projection/dense')
-      self.proj_layer_norm = tf.keras.layers.LayerNormalization(
-          axis=-1, epsilon=1e-12, name='lm_projection/LayerNorm')
-    if not self.tie_weight:
-      self.softmax_w = self.add_weight(
-          'weight',
-          shape=[self.n_token, self.d_model],
-          initializer=self.initializer)
-
-    self.softmax_b = self.add_weight(
-        'bias', shape=[self.n_token], initializer=tf.zeros_initializer())
-
-    super(LMLossLayer, self).build(unused_input_shapes)
-
-  def call(self, hidden, target, lookup_table, target_mask):
-    """Implements call() for the layer."""
-    if self.use_proj:
-      hidden = self.proj_layer_norm(self.proj_layer(hidden))
-    if self.tie_weight:
-      logits = tf.einsum('ibd,nd->ibn', hidden, lookup_table) + self.softmax_b
-    else:
-      logits = tf.einsum('ibd,nd->ibn', hidden, self.softmax_w) + self.softmax_b
-
-    if self.use_tpu:
-      one_hot_target = tf.one_hot(target, self.n_token, dtype=logits.dtype)
-      loss = -tf.reduce_sum(tf.nn.log_softmax(logits) * one_hot_target, -1)
-    else:
-      loss = tf.nn.sparse_softmax_cross_entropy_with_logits(
-          labels=target, logits=logits)
-
-    total_loss = tf.reduce_sum(loss * target_mask) / tf.reduce_sum(target_mask)
-
-    return total_loss, logits
-
-
-class Summarization(tf.keras.layers.Layer):
-  """The layer to pool the output from XLNet model into a vector."""
-
-  def __init__(self,
-               d_model,
-               n_head,
-               d_head,
-               dropout,
-               dropout_att,
-               initializer,
-               use_proj=True,
-               summary_type='last',
-               **kwargs):
-    """Constructs Summarization layer.
-
-    Args:
-      d_model: int, the dimension of model hidden state.
-      n_head: int, the number of attention heads.
-      d_head: int, the dimension size of each attention head.
-      dropout: float, dropout rate.
-      dropout_att: float, dropout rate on attention probabilities.
-      initializer: Initializer used for parameters.
-      use_proj: bool, whether to use projection layer for summarization.
-      summary_type: Method used to summarize a sequence into a compact vector.
-      **kwargs: Other parameters.
-    """
-    super(Summarization, self).__init__(**kwargs)
-    self.d_model = d_model
-    self.n_head = n_head
-    self.d_head = d_head
-    self.initializer = initializer
-
-    self.dropout = dropout
-    self.dropout_att = dropout_att
-    self.use_proj = use_proj
-    self.summary_type = summary_type
-
-  def build(self, unused_input_shapes):
-    """Implements build() for the layer."""
-    if self.use_proj:
-      self.proj_layer = tf.keras.layers.Dense(
-          units=self.d_model,
-          kernel_initializer=self.initializer,
-          activation=tf.nn.tanh,
-          name='summary')
-    self.dropout_layer = tf.keras.layers.Dropout(rate=self.dropout)
-
-    super(Summarization, self).build(unused_input_shapes)
-
-  def call(self, inputs):
-    """Implements call() for the layer."""
-    if self.summary_type == 'last':
-      summary = inputs[-1]
-    elif self.summary_type == 'first':
-      summary = inputs[0]
-    else:
-      raise ValueError('Invalid summary type provided: %s' % self.summary_type)
-    if self.use_proj:
-      summary = self.proj_layer(summary)
-    summary = self.dropout_layer(summary)
-    return summary
-
-
-class ClassificationLossLayer(tf.keras.layers.Layer):
-  """Layer computing cross entropy loss for classification task."""
-
-  def __init__(self, n_class, initializer, **kwargs):
-    """Constructs Summarization layer.
-
-    Args:
-      n_class: Number of tokens in vocabulary.
-      initializer: Initializer used for parameters.
-      **kwargs: Other parameters.
-    """
-    super(ClassificationLossLayer, self).__init__(**kwargs)
-
-    self.n_class = n_class
-    self.initializer = initializer
-
-  def build(self, unused_input_shapes):
-    """Implements build() for the layer."""
-    self.proj_layer = tf.keras.layers.Dense(
-        units=self.n_class, kernel_initializer=self.initializer, name='logit')
-
-    super(ClassificationLossLayer, self).build(unused_input_shapes)
-
-  def call(self, hidden, labels):
-    """Implements call() for the layer."""
-
-    logits = self.proj_layer(hidden)
-    one_hot_target = tf.one_hot(labels, self.n_class, dtype=hidden.dtype)  # pytype: disable=attribute-error
-    loss = -tf.reduce_sum(tf.nn.log_softmax(logits) * one_hot_target, -1)
-
-    return loss, logits
-
-
-class QAXLNetModel(tf.keras.Model):
-  """XLNet keras model combined with question answering loss layer.
-
-  See the original paper: https://arxiv.org/pdf/1906.08237.pdf
-
-  """
-
-  def __init__(self, xlnet_config, run_config, start_n_top, end_n_top,
-               **kwargs):
-    super(QAXLNetModel, self).__init__(**kwargs)
-    self.run_config = run_config
-    self.initializer = _get_initializer(run_config)
-    self.xlnet_config = copy.deepcopy(xlnet_config)
-
-    self.transformerxl_model = TransformerXLModel(
-        n_token=self.xlnet_config.n_token,
-        initializer=self.initializer,
-        attn_type='bi',
-        n_layer=self.xlnet_config.n_layer,
-        d_model=self.xlnet_config.d_model,
-        n_head=self.xlnet_config.n_head,
-        d_head=self.xlnet_config.d_head,
-        d_inner=self.xlnet_config.d_inner,
-        ff_activation=self.xlnet_config.ff_activation,
-        untie_r=self.xlnet_config.untie_r,
-        is_training=self.run_config.is_training,
-        use_tpu=self.run_config.use_tpu,
-        dropout=self.run_config.dropout,
-        dropout_att=self.run_config.dropout_att,
-        mem_len=self.run_config.mem_len,
-        reuse_len=self.run_config.reuse_len,
-        bi_data=self.run_config.bi_data,
-        clamp_len=self.run_config.clamp_len,
-        same_length=self.run_config.same_length,
-        name='transformer')
-
-    self.qa_loss_layer = QALossLayer(
-        d_model=self.xlnet_config.d_model,
-        start_n_top=start_n_top,
-        end_n_top=end_n_top,
-        initializer=self.initializer,
-        dropout=self.run_config.dropout)
-
-  def call(self, features, training=False):
-    """Implements call() for the layer."""
-
-    input_ids = tf.transpose(features['input_ids'], [1, 0])
-    seg_ids = tf.transpose(features['segment_ids'], [1, 0])
-    input_mask = tf.transpose(features['input_mask'], [1, 0])
-
-    cls_index = tf.reshape(features['cls_index'], [-1])
-    p_mask = features['p_mask']
-
-    transformerxl_output, new_mems, self.lookup_table = (
-        self.transformerxl_model(input_ids, seg_ids, input_mask))
-
-    if training:
-      loss, logits = self.qa_loss_layer(
-          hidden=transformerxl_output,
-          p_mask=p_mask,
-          cls_index=cls_index,
-          start_positions=features['start_positions'],
-          end_positions=features['end_positions'],
-          is_impossible=features['is_impossible'])
-      self.add_loss(loss)
-      return new_mems, logits
-    else:
-      results = self.qa_loss_layer(
-          hidden=transformerxl_output, p_mask=p_mask, cls_index=cls_index)
-      return results
-
-
-class QALossLayer(tf.keras.layers.Layer):
-  """Layer computing position and regression loss for question answering task."""
-
-  def __init__(self, d_model, start_n_top, end_n_top, initializer, dropout,
-               **kwargs):
-    """Constructs Summarization layer.
-
-    Args:
-      d_model: Int, the hidden size.
-      start_n_top: Beam size for span start.
-      end_n_top: Beam size for span end.
-      initializer: Initializer used for parameters.
-      dropout: float, dropout rate.
-      **kwargs: Other parameters.
-    """
-    super(QALossLayer, self).__init__(**kwargs)
-    self.d_model = d_model
-    self.start_n_top = start_n_top
-    self.end_n_top = end_n_top
-    self.initializer = initializer
-    self.dropout = dropout
-
-  def build(self, unused_input_shapes):
-    """Implements build() for the layer."""
-    self.start_logits_proj_layer = tf.keras.layers.Dense(
-        units=1, kernel_initializer=self.initializer, name='start_logits/dense')
-    self.end_logits_proj_layer0 = tf.keras.layers.Dense(
-        units=self.d_model,
-        kernel_initializer=self.initializer,
-        activation=tf.nn.tanh,
-        name='end_logits/dense_0')
-    self.end_logits_proj_layer1 = tf.keras.layers.Dense(
-        units=1, kernel_initializer=self.initializer, name='end_logits/dense_1')
-    self.end_logits_layer_norm = tf.keras.layers.LayerNormalization(
-        axis=-1, epsilon=1e-12, name='end_logits/LayerNorm')
-    self.answer_class_proj_layer0 = tf.keras.layers.Dense(
-        units=self.d_model,
-        kernel_initializer=self.initializer,
-        activation=tf.nn.tanh,
-        name='answer_class/dense_0')
-    self.answer_class_proj_layer1 = tf.keras.layers.Dense(
-        units=1,
-        kernel_initializer=self.initializer,
-        use_bias=False,
-        name='answer_class/dense_1')
-    self.ans_feature_dropout = tf.keras.layers.Dropout(rate=self.dropout)
-    super(QALossLayer, self).build(unused_input_shapes)
-
-  def __call__(self, hidden, p_mask, cls_index, **kwargs):
-    return super(QALossLayer, self).__call__(
-        (hidden, p_mask, cls_index, kwargs))
-
-  def call(self, inputs, training=False):
-    """Implements call() for the layer."""
-    hidden, p_mask, cls_index, kwargs = inputs
-    return_dict = {}
-    seq_len = tf.shape(hidden)[0]
-
-    start_logits = self.start_logits_proj_layer(hidden)
-    start_logits = tf.transpose(tf.squeeze(start_logits, -1), [1, 0])
-    start_logits_masked = start_logits * (1 - p_mask) - 1e30 * p_mask
-    start_log_probs = tf.nn.log_softmax(start_logits_masked, -1)
-    if training:
-      start_positions = kwargs['start_positions']
-      end_positions = kwargs['end_positions']
-      is_impossible = kwargs['is_impossible']
-      start_positions = tf.reshape(start_positions, [-1])
-      start_index = tf.one_hot(
-          start_positions, depth=seq_len, axis=-1, dtype=tf.float32)
-      start_features = tf.einsum('lbh,bl->bh', hidden, start_index)
-      start_features = tf.tile(start_features[None], [seq_len, 1, 1])
-      end_logits = self.end_logits_proj_layer0(
-          tf.concat([hidden, start_features], axis=-1))
-
-      end_logits = self.end_logits_layer_norm(end_logits)
-
-      end_logits = self.end_logits_proj_layer1(end_logits)
-      end_logits = tf.transpose(tf.squeeze(end_logits, -1), [1, 0])
-      end_logits_masked = end_logits * (1 - p_mask) - 1e30 * p_mask
-      end_log_probs = tf.nn.log_softmax(end_logits_masked, -1)
-    else:
-      # during inference, compute the end logits based on beam search
-
-      start_top_log_probs, start_top_index = tf.nn.top_k(
-          start_log_probs, k=self.start_n_top)
-      start_index = tf.one_hot(
-          start_top_index, depth=seq_len, axis=-1, dtype=tf.float32)
-      start_features = tf.einsum('lbh,bkl->bkh', hidden, start_index)
-      end_input = tf.tile(hidden[:, :, None], [1, 1, self.start_n_top, 1])
-      start_features = tf.tile(start_features[None], [seq_len, 1, 1, 1])
-      end_input = tf.concat([end_input, start_features], axis=-1)
-      end_logits = self.end_logits_proj_layer0(end_input)
-      end_logits = tf.reshape(end_logits, [seq_len, -1, self.d_model])
-      end_logits = self.end_logits_layer_norm(end_logits)
-
-      end_logits = tf.reshape(end_logits,
-                              [seq_len, -1, self.start_n_top, self.d_model])
-
-      end_logits = self.end_logits_proj_layer1(end_logits)
-      end_logits = tf.reshape(end_logits, [seq_len, -1, self.start_n_top])
-      end_logits = tf.transpose(end_logits, [1, 2, 0])
-      end_logits_masked = end_logits * (
-          1 - p_mask[:, None]) - 1e30 * p_mask[:, None]
-      end_log_probs = tf.nn.log_softmax(end_logits_masked, -1)
-      end_top_log_probs, end_top_index = tf.nn.top_k(
-          end_log_probs, k=self.end_n_top)
-      end_top_log_probs = tf.reshape(end_top_log_probs,
-                                     [-1, self.start_n_top * self.end_n_top])
-      end_top_index = tf.reshape(end_top_index,
-                                 [-1, self.start_n_top * self.end_n_top])
-
-    if training:
-      return_dict['start_log_probs'] = start_log_probs
-      return_dict['end_log_probs'] = end_log_probs
-    else:
-      return_dict['start_top_log_probs'] = start_top_log_probs
-      return_dict['start_top_index'] = start_top_index
-      return_dict['end_top_log_probs'] = end_top_log_probs
-      return_dict['end_top_index'] = end_top_index
-    # an additional layer to predict answerability
-
-    # get the representation of CLS
-    cls_index = tf.one_hot(cls_index, seq_len, axis=-1, dtype=tf.float32)
-    cls_feature = tf.einsum('lbh,bl->bh', hidden, cls_index)
-
-    # get the representation of START
-    start_p = tf.nn.softmax(start_logits_masked, axis=-1, name='softmax_start')
-    start_feature = tf.einsum('lbh,bl->bh', hidden, start_p)
-
-    ans_feature = tf.concat([start_feature, cls_feature], -1)
-    ans_feature = self.answer_class_proj_layer0(ans_feature)
-    ans_feature = self.ans_feature_dropout(ans_feature)
-    cls_logits = self.answer_class_proj_layer1(ans_feature)
-    cls_logits = tf.squeeze(cls_logits, -1)
-    return_dict['cls_logits'] = cls_logits
-
-    if not training:
-      return return_dict
-
-    def compute_loss(log_probs, positions):
-      one_hot_positions = tf.one_hot(positions, depth=seq_len, dtype=tf.float32)
-
-      loss = -tf.reduce_sum(one_hot_positions * log_probs, axis=-1)
-      loss = tf.reduce_mean(loss)
-      return loss
-
-    start_loss = compute_loss(start_log_probs, start_positions)
-    end_loss = compute_loss(end_log_probs, end_positions)
-
-    total_loss = (start_loss + end_loss) * 0.5
-
-    is_impossible = tf.reshape(is_impossible, [-1])
-    regression_loss = tf.nn.sigmoid_cross_entropy_with_logits(
-        labels=is_impossible, logits=cls_logits)
-    regression_loss = tf.reduce_mean(regression_loss)
-
-    total_loss += regression_loss * 0.5
-    return total_loss, cls_logits
diff --git a/spaces/Nee001/bing0/src/app/loading.css b/spaces/Nee001/bing0/src/app/loading.css
deleted file mode 100644
index eaaab6a86a228334c4eca3c5368ae6f0f593d405..0000000000000000000000000000000000000000
--- a/spaces/Nee001/bing0/src/app/loading.css
+++ /dev/null
@@ -1,68 +0,0 @@
-::-webkit-scrollbar {
-  width: 10px;
-  height: 10px;
-  display: none;
-}
-
-::-webkit-scrollbar-button:start:decrement,
-::-webkit-scrollbar-button:end:increment {
-  height: 30px;
-  background-color: transparent;
-}
-
-::-webkit-scrollbar-track-piece {
-  background-color: #3b3b3b;
-  -webkit-border-radius: 16px;
-}
-
-::-webkit-scrollbar-thumb:vertical {
-  height: 50px;
-  background-color: #666;
-  border: 1px solid #eee;
-  -webkit-border-radius: 6px;
-}
-
-/* loading start */
-.loading-spinner {
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  height: 100vh;
-  opacity: 1;
-  transition: opacity .8s ease-out;
-}
-
-.loading-spinner.hidden {
-  opacity: 0;
-}
-
-.loading-spinner>div {
-  width: 30px;
-  height: 30px;
-  background: linear-gradient(90deg, #2870EA 10.79%, #1B4AEF 87.08%);
-
-  border-radius: 100%;
-  display: inline-block;
-  animation: sk-bouncedelay 1.4s infinite ease-in-out both;
-}
-
-.loading-spinner .bounce1 {
-  animation-delay: -0.32s;
-}
-
-.loading-spinner .bounce2 {
-  animation-delay: -0.16s;
-}
-
-@keyframes sk-bouncedelay {
-
-  0%,
-  80%,
-  100% {
-    transform: scale(0);
-  }
-
-  40% {
-    transform: scale(1.0);
-  }
-}
diff --git a/spaces/NeuralInternet/BabyAGI/babyagi.py b/spaces/NeuralInternet/BabyAGI/babyagi.py
deleted file mode 100644
index fb0d9f36e1cf7146dd1880a1f780a2ec071e14ea..0000000000000000000000000000000000000000
--- a/spaces/NeuralInternet/BabyAGI/babyagi.py
+++ /dev/null
@@ -1,278 +0,0 @@
-from collections import deque
-from typing import Dict, List, Optional
-from langchain import LLMChain, OpenAI, PromptTemplate
-from langchain.embeddings import HuggingFaceEmbeddings
-from langchain.llms import BaseLLM
-from langchain.vectorstores import FAISS
-from langchain.vectorstores.base import VectorStore
-from pydantic import BaseModel, Field
-import streamlit as st
-
-class TaskCreationChain(LLMChain):
-    @classmethod
-    def from_llm(cls, llm: BaseLLM, objective: str, verbose: bool = True) -> LLMChain:
-        """Get the response parser."""
-        task_creation_template = (
-            "You are an task creation AI that uses the result of an execution agent"
-            " to create new tasks with the following objective: {objective},"
-            " The last completed task has the result: {result}."
-            " This result was based on this task description: {task_description}."
-            " These are incomplete tasks: {incomplete_tasks}."
-            " Based on the result, create new tasks to be completed"
-            " by the AI system that do not overlap with incomplete tasks."
-            " Return the tasks as an array."
-        )
-        prompt = PromptTemplate(
-            template=task_creation_template,
-            partial_variables={"objective": objective},
-            input_variables=["result", "task_description", "incomplete_tasks"],
-        )
-        return cls(prompt=prompt, llm=llm, verbose=verbose)
-    
-    def get_next_task(self, result: Dict, task_description: str, task_list: List[str]) -> List[Dict]:
-        """Get the next task."""
-        incomplete_tasks = ", ".join(task_list)
-        response = self.run(result=result, task_description=task_description, incomplete_tasks=incomplete_tasks)
-        new_tasks = response.split('\n')
-        return [{"task_name": task_name} for task_name in new_tasks if task_name.strip()]
-    
-
-class TaskPrioritizationChain(LLMChain):
-    """Chain to prioritize tasks."""
-
-    @classmethod
-    def from_llm(cls, llm: BaseLLM, objective: str, verbose: bool = True) -> LLMChain:
-        """Get the response parser."""
-        task_prioritization_template = (
-            "You are an task prioritization AI tasked with cleaning the formatting of and reprioritizing"
-            " the following tasks: {task_names}."
-            " Consider the ultimate objective of your team: {objective}."
-            " Do not remove any tasks. Return the result as a numbered list, like:"
-            " #. First task"
-            " #. Second task"
-            " Start the task list with number {next_task_id}."
-        )
-        prompt = PromptTemplate(
-            template=task_prioritization_template,
-            partial_variables={"objective": objective},
-            input_variables=["task_names", "next_task_id"],
-        )
-        return cls(prompt=prompt, llm=llm, verbose=verbose)
-
-    def prioritize_tasks(self, this_task_id: int, task_list: List[Dict]) -> List[Dict]:
-        """Prioritize tasks."""
-        task_names = [t["task_name"] for t in task_list]
-        next_task_id = int(this_task_id) + 1
-        response = self.run(task_names=task_names, next_task_id=next_task_id)
-        new_tasks = response.split('\n')
-        prioritized_task_list = []
-        for task_string in new_tasks:
-            if not task_string.strip():
-                continue
-            task_parts = task_string.strip().split(".", 1)
-            if len(task_parts) == 2:
-                task_id = task_parts[0].strip()
-                task_name = task_parts[1].strip()
-                prioritized_task_list.append({"task_id": task_id, "task_name": task_name})
-        return prioritized_task_list
-
-        
-class ExecutionChain(LLMChain):
-    """Chain to execute tasks."""
-    
-    vectorstore: VectorStore = Field(init=False)
-
-    @classmethod
-    def from_llm(cls, llm: BaseLLM, vectorstore: VectorStore, verbose: bool = True) -> LLMChain:
-        """Get the response parser."""
-        execution_template = (
-            "You are an AI who performs one task based on the following objective: {objective}."
-            " Take into account these previously completed tasks: {context}."
-            " Your task: {task}."
-            " Response:"
-        )
-        prompt = PromptTemplate(
-            template=execution_template,
-            input_variables=["objective", "context", "task"],
-        )
-        return cls(prompt=prompt, llm=llm, verbose=verbose, vectorstore=vectorstore)
-    
-    def _get_top_tasks(self, query: str, k: int) -> List[str]:
-        """Get the top k tasks based on the query."""
-        results = self.vectorstore.similarity_search_with_score(query, k=k)
-        if not results:
-            return []
-        sorted_results, _ = zip(*sorted(results, key=lambda x: x[1], reverse=True))
-        return [str(item.metadata['task']) for item in sorted_results]
-    
-    def execute_task(self, objective: str, task: str, k: int = 5) -> str:
-        """Execute a task."""
-        context = self._get_top_tasks(query=objective, k=k)
-        return self.run(objective=objective, context=context, task=task)
-
-
-class Message:
-    exp: st.expander
-    ai_icon = "./img/robot.png"
-
-    def __init__(self, label: str):
-        message_area, icon_area = st.columns([10, 1])
-        icon_area.image(self.ai_icon, caption="BabyAGI")
-
-        # Expander
-        self.exp = message_area.expander(label=label, expanded=True)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, ex_type, ex_value, trace):
-        pass
-
-    def write(self, content):
-        self.exp.markdown(content)
-
-
-class BabyAGI(BaseModel):
-    """Controller model for the BabyAGI agent."""
-
-    objective: str = Field(alias="objective")
-    task_list: deque = Field(default_factory=deque)
-    task_creation_chain: TaskCreationChain = Field(...)
-    task_prioritization_chain: TaskPrioritizationChain = Field(...)
-    execution_chain: ExecutionChain = Field(...)
-    task_id_counter: int = Field(1)
-
-    def add_task(self, task: Dict):
-        self.task_list.append(task)
-
-    def print_task_list(self):
-        with Message(label="Task List") as m:
-            m.write("### Task List")
-            for t in self.task_list:
-                m.write("- " + str(t["task_id"]) + ": " + t["task_name"])
-                m.write("")
-
-    def print_next_task(self, task: Dict):
-        with Message(label="Next Task") as m:
-            m.write("### Next Task")
-            m.write("- " + str(task["task_id"]) + ": " + task["task_name"])
-            m.write("")
-
-    def print_task_result(self, result: str):
-        with Message(label="Task Result") as m:
-            m.write("### Task Result")
-            m.write(result)
-            m.write("")
-
-    def print_task_ending(self):
-        with Message(label="Task Ending") as m:
-            m.write("### Task Ending")
-            m.write("")
-
-
-    def run(self, max_iterations: Optional[int] = None):
-        """Run the agent."""
-        num_iters = 0
-        while True:
-            if self.task_list:
-                self.print_task_list()
-
-                # Step 1: Pull the first task
-                task = self.task_list.popleft()
-                self.print_next_task(task)
-
-                # Step 2: Execute the task
-                result = self.execution_chain.execute_task(
-                    self.objective, task["task_name"]
-                )
-                this_task_id = int(task["task_id"])
-                self.print_task_result(result)
-
-                # Step 3: Store the result in Pinecone
-                result_id = f"result_{task['task_id']}"
-                self.execution_chain.vectorstore.add_texts(
-                    texts=[result],
-                    metadatas=[{"task": task["task_name"]}],
-                    ids=[result_id],
-                )
-
-                # Step 4: Create new tasks and reprioritize task list
-                new_tasks = self.task_creation_chain.get_next_task(
-                    result, task["task_name"], [t["task_name"] for t in self.task_list]
-                )
-                for new_task in new_tasks:
-                    self.task_id_counter += 1
-                    new_task.update({"task_id": self.task_id_counter})
-                    self.add_task(new_task)
-                self.task_list = deque(
-                    self.task_prioritization_chain.prioritize_tasks(
-                        this_task_id, list(self.task_list)
-                    )
-                )
-            num_iters += 1
-            if max_iterations is not None and num_iters == max_iterations:
-                self.print_task_ending()
-                break
-
-    @classmethod
-    def from_llm_and_objectives(
-        cls,
-        llm: BaseLLM,
-        vectorstore: VectorStore,
-        objective: str,
-        first_task: str,
-        verbose: bool = False,
-    ) -> "BabyAGI":
-        """Initialize the BabyAGI Controller."""
-        task_creation_chain = TaskCreationChain.from_llm(
-            llm, objective, verbose=verbose
-        )
-        task_prioritization_chain = TaskPrioritizationChain.from_llm(
-            llm, objective, verbose=verbose
-        )
-        execution_chain = ExecutionChain.from_llm(llm, vectorstore, verbose=verbose)
-        controller =  cls(
-            objective=objective,
-            task_creation_chain=task_creation_chain,
-            task_prioritization_chain=task_prioritization_chain,
-            execution_chain=execution_chain,
-        )
-        controller.add_task({"task_id": 1, "task_name": first_task})
-        return controller
-
-
-def main():
-    st.set_page_config(
-        initial_sidebar_state="expanded",
-        page_title="BabyAGI Streamlit",
-        layout="centered",
-    )
-
-    with st.sidebar:
-        openai_api_key = st.text_input('Your OpenAI API KEY', type="password")
-
-    st.title("BabyAGI Streamlit")
-    objective = st.text_input("Input Ultimate goal", "Solve world hunger")
-    first_task = st.text_input("Input Where to start", "Develop a task list")
-    max_iterations = st.number_input("Max iterations", value=3, min_value=1, step=1)
-    button = st.button("Run")
-
-    embedding_model = HuggingFaceEmbeddings()
-    vectorstore = FAISS.from_texts(["_"], embedding_model, metadatas=[{"task":first_task}])
-
-    if button:
-        try:
-            baby_agi = BabyAGI.from_llm_and_objectives(
-                llm=OpenAI(openai_api_key=openai_api_key),
-                vectorstore=vectorstore,
-                objective=objective,
-                first_task=first_task,
-                verbose=False
-            )
-            baby_agi.run(max_iterations=max_iterations)
-        except Exception as e:
-            st.error(e)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/spaces/Nickwwww572/Test02/README.md b/spaces/Nickwwww572/Test02/README.md
deleted file mode 100644
index fe48fb9329316f43b7cf367d8b545c7f8206ea61..0000000000000000000000000000000000000000
--- a/spaces/Nickwwww572/Test02/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Test02
-emoji: 🔥
-colorFrom: gray
-colorTo: indigo
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/speech_recognition/criterions/cross_entropy_acc.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/speech_recognition/criterions/cross_entropy_acc.py
deleted file mode 100644
index 7c4d8ba3802a2da9467c42b0aa18653c7bbb2ec9..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/speech_recognition/criterions/cross_entropy_acc.py
+++ /dev/null
@@ -1,130 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from __future__ import absolute_import, division, print_function, unicode_literals
-
-import logging
-import math
-
-import torch
-import torch.nn.functional as F
-from fairseq import utils
-from fairseq.criterions import FairseqCriterion, register_criterion
-
-
-@register_criterion("cross_entropy_acc")
-class CrossEntropyWithAccCriterion(FairseqCriterion):
-    def __init__(self, task, sentence_avg):
-        super().__init__(task)
-        self.sentence_avg = sentence_avg
-
-    def compute_loss(self, model, net_output, target, reduction, log_probs):
-        # N, T -> N * T
-        target = target.view(-1)
-        lprobs = model.get_normalized_probs(net_output, log_probs=log_probs)
-        if not hasattr(lprobs, "batch_first"):
-            logging.warning(
-                "ERROR: we need to know whether "
-                "batch first for the net output; "
-                "you need to set batch_first attribute for the return value of "
-                "model.get_normalized_probs. Now, we assume this is true, but "
-                "in the future, we will raise exception instead. "
-            )
-        batch_first = getattr(lprobs, "batch_first", True)
-        if not batch_first:
-            lprobs = lprobs.transpose(0, 1)
-
-        # N, T, D -> N * T, D
-        lprobs = lprobs.view(-1, lprobs.size(-1))
-        loss = F.nll_loss(
-            lprobs, target, ignore_index=self.padding_idx, reduction=reduction
-        )
-        return lprobs, loss
-
-    def get_logging_output(self, sample, target, lprobs, loss):
-        target = target.view(-1)
-        mask = target != self.padding_idx
-        correct = torch.sum(
-            lprobs.argmax(1).masked_select(mask) == target.masked_select(mask)
-        )
-        total = torch.sum(mask)
-        sample_size = (
-            sample["target"].size(0) if self.sentence_avg else sample["ntokens"]
-        )
-
-        logging_output = {
-            "loss": utils.item(loss.data),  # * sample['ntokens'],
-            "ntokens": sample["ntokens"],
-            "nsentences": sample["target"].size(0),
-            "sample_size": sample_size,
-            "correct": utils.item(correct.data),
-            "total": utils.item(total.data),
-            "nframes": torch.sum(sample["net_input"]["src_lengths"]).item(),
-        }
-
-        return sample_size, logging_output
-
-    def forward(self, model, sample, reduction="sum", log_probs=True):
-        """Computes the cross entropy with accuracy metric for the given sample.
-
-        This is similar to CrossEntropyCriterion in fairseq, but also
-        computes accuracy metrics as part of logging
-
-        Args:
-            logprobs (Torch.tensor) of shape N, T, D i.e.
-                batchsize, timesteps, dimensions
-            targets (Torch.tensor) of shape N, T  i.e batchsize, timesteps
-
-        Returns:
-        tuple: With three elements:
-            1) the loss
-            2) the sample size, which is used as the denominator for the gradient
-            3) logging outputs to display while training
-
-        TODO:
-            * Currently this Criterion will only work with LSTMEncoderModels or
-            FairseqModels which have decoder, or Models which return TorchTensor
-            as net_output.
-            We need to make a change to support all FairseqEncoder models.
-        """
-        net_output = model(**sample["net_input"])
-        target = model.get_targets(sample, net_output)
-        lprobs, loss = self.compute_loss(
-            model, net_output, target, reduction, log_probs
-        )
-        sample_size, logging_output = self.get_logging_output(
-            sample, target, lprobs, loss
-        )
-        return loss, sample_size, logging_output
-
-    @staticmethod
-    def aggregate_logging_outputs(logging_outputs):
-        """Aggregate logging outputs from data parallel training."""
-        correct_sum = sum(log.get("correct", 0) for log in logging_outputs)
-        total_sum = sum(log.get("total", 0) for log in logging_outputs)
-        loss_sum = sum(log.get("loss", 0) for log in logging_outputs)
-        ntokens = sum(log.get("ntokens", 0) for log in logging_outputs)
-        nsentences = sum(log.get("nsentences", 0) for log in logging_outputs)
-        sample_size = sum(log.get("sample_size", 0) for log in logging_outputs)
-        nframes = sum(log.get("nframes", 0) for log in logging_outputs)
-        agg_output = {
-            "loss": loss_sum / sample_size / math.log(2) if sample_size > 0 else 0.0,
-            # if args.sentence_avg, then sample_size is nsentences, then loss
-            # is per-sentence loss; else sample_size is ntokens, the loss
-            # becomes per-output token loss
-            "ntokens": ntokens,
-            "nsentences": nsentences,
-            "nframes": nframes,
-            "sample_size": sample_size,
-            "acc": correct_sum * 100.0 / total_sum if total_sum > 0 else 0.0,
-            "correct": correct_sum,
-            "total": total_sum,
-            # total is the number of validate tokens
-        }
-        if sample_size != ntokens:
-            agg_output["nll_loss"] = loss_sum / ntokens / math.log(2)
-        # loss: per output token loss
-        # nll_loss: per sentence loss
-        return agg_output
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/data/raw_label_dataset.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/data/raw_label_dataset.py
deleted file mode 100644
index d054904f419bd64855d33a2a770b43f671c7c8d8..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/data/raw_label_dataset.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import torch
-
-from . import FairseqDataset
-
-
-class RawLabelDataset(FairseqDataset):
-    def __init__(self, labels):
-        super().__init__()
-        self.labels = labels
-
-    def __getitem__(self, index):
-        return self.labels[index]
-
-    def __len__(self):
-        return len(self.labels)
-
-    def collater(self, samples):
-        return torch.tensor(samples)
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/utils/BPE/__init__.py b/spaces/OFA-Sys/OFA-Generic_Interface/utils/BPE/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/utils/cider/pyciderevalcap/ciderD/ciderD_scorer.py b/spaces/OFA-Sys/OFA-Generic_Interface/utils/cider/pyciderevalcap/ciderD/ciderD_scorer.py
deleted file mode 100644
index 144f58350322bcae42e152300778f491908a1576..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/utils/cider/pyciderevalcap/ciderD/ciderD_scorer.py
+++ /dev/null
@@ -1,222 +0,0 @@
-#!/usr/bin/env python
-# Tsung-Yi Lin <tl483@cornell.edu>
-# Ramakrishna Vedantam <vrama91@vt.edu>
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import copy
-from collections import defaultdict
-import numpy as np
-import pdb
-import math
-import six
-from six.moves import cPickle
-import os
-
-def precook(s, n=4, out=False):
-    """
-    Takes a string as input and returns an object that can be given to
-    either cook_refs or cook_test. This is optional: cook_refs and cook_test
-    can take string arguments as well.
-    :param s: string : sentence to be converted into ngrams
-    :param n: int    : number of ngrams for which representation is calculated
-    :return: term frequency vector for occuring ngrams
-    """
-    words = s.split()
-    counts = defaultdict(int)
-    for k in range(1,n+1):
-        for i in range(len(words)-k+1):
-            ngram = tuple(words[i:i+k])
-            counts[ngram] += 1
-    return counts
-
-def cook_refs(refs, n=4): ## lhuang: oracle will call with "average"
-    '''Takes a list of reference sentences for a single segment
-    and returns an object that encapsulates everything that BLEU
-    needs to know about them.
-    :param refs: list of string : reference sentences for some image
-    :param n: int : number of ngrams for which (ngram) representation is calculated
-    :return: result (list of dict)
-    '''
-    return [precook(ref, n) for ref in refs]
-
-def cook_test(test, n=4):
-    '''Takes a test sentence and returns an object that
-    encapsulates everything that BLEU needs to know about it.
-    :param test: list of string : hypothesis sentence for some image
-    :param n: int : number of ngrams for which (ngram) representation is calculated
-    :return: result (dict)
-    '''
-    return precook(test, n, True)
-
-class CiderScorer(object):
-    """CIDEr scorer.
-    """
-
-    def copy(self):
-        ''' copy the refs.'''
-        new = CiderScorer(n=self.n)
-        new.ctest = copy.copy(self.ctest)
-        new.crefs = copy.copy(self.crefs)
-        return new
-
-    def copy_empty(self):
-        new = CiderScorer(df_mode="corpus", n=self.n, sigma=self.sigma)
-        new.df_mode = self.df_mode
-        new.ref_len = self.ref_len
-        new.document_frequency = self.document_frequency
-        return new
-
-    def __init__(self, df_mode="corpus", test=None, refs=None, n=4, sigma=6.0):
-        ''' singular instance '''
-        self.n = n
-        self.sigma = sigma
-        self.crefs = []
-        self.ctest = []
-        self.df_mode = df_mode
-        self.ref_len = None
-        if self.df_mode != "corpus":
-            pkl_file = cPickle.load(open(df_mode,'rb'), **(dict(encoding='latin1') if six.PY3 else {}))
-            self.ref_len = np.log(float(pkl_file['ref_len']))
-            self.document_frequency = pkl_file['document_frequency']
-        else:
-            self.document_frequency = None
-        self.cook_append(test, refs)
-    
-    def clear(self):
-        self.crefs = []
-        self.ctest = []
-
-    def cook_append(self, test, refs):
-        '''called by constructor and __iadd__ to avoid creating new instances.'''
-
-        if refs is not None:
-            self.crefs.append(cook_refs(refs))
-            if test is not None:
-                self.ctest.append(cook_test(test)) ## N.B.: -1
-            else:
-                self.ctest.append(None) # lens of crefs and ctest have to match
-
-    def size(self):
-        assert len(self.crefs) == len(self.ctest), "refs/test mismatch! %d<>%d" % (len(self.crefs), len(self.ctest))
-        return len(self.crefs)
-
-    def __iadd__(self, other):
-        '''add an instance (e.g., from another sentence).'''
-
-        if type(other) is tuple:
-            ## avoid creating new CiderScorer instances
-            self.cook_append(other[0], other[1])
-        else:
-            self.ctest.extend(other.ctest)
-            self.crefs.extend(other.crefs)
-
-        return self
-    def compute_doc_freq(self):
-        '''
-        Compute term frequency for reference data.
-        This will be used to compute idf (inverse document frequency later)
-        The term frequency is stored in the object
-        :return: None
-        '''
-        for refs in self.crefs:
-            # refs, k ref captions of one image
-            for ngram in set([ngram for ref in refs for (ngram,count) in ref.items()]):
-                self.document_frequency[ngram] += 1
-            # maxcounts[ngram] = max(maxcounts.get(ngram,0), count)
-
-    def compute_cider(self):
-        def counts2vec(cnts):
-            """
-            Function maps counts of ngram to vector of tfidf weights.
-            The function returns vec, an array of dictionary that store mapping of n-gram and tf-idf weights.
-            The n-th entry of array denotes length of n-grams.
-            :param cnts:
-            :return: vec (array of dict), norm (array of float), length (int)
-            """
-            vec = [defaultdict(float) for _ in range(self.n)]
-            length = 0
-            norm = [0.0 for _ in range(self.n)]
-            for (ngram,term_freq) in cnts.items():
-                # give word count 1 if it doesn't appear in reference corpus
-                df = np.log(max(1.0, self.document_frequency[ngram]))
-                # ngram index
-                n = len(ngram)-1
-                # tf (term_freq) * idf (precomputed idf) for n-grams
-                vec[n][ngram] = float(term_freq)*(self.ref_len - df)
-                # compute norm for the vector.  the norm will be used for computing similarity
-                norm[n] += pow(vec[n][ngram], 2)
-
-                if n == 1:
-                    length += term_freq
-            norm = [np.sqrt(n) for n in norm]
-            return vec, norm, length
-
-        def sim(vec_hyp, vec_ref, norm_hyp, norm_ref, length_hyp, length_ref):
-            '''
-            Compute the cosine similarity of two vectors.
-            :param vec_hyp: array of dictionary for vector corresponding to hypothesis
-            :param vec_ref: array of dictionary for vector corresponding to reference
-            :param norm_hyp: array of float for vector corresponding to hypothesis
-            :param norm_ref: array of float for vector corresponding to reference
-            :param length_hyp: int containing length of hypothesis
-            :param length_ref: int containing length of reference
-            :return: array of score for each n-grams cosine similarity
-            '''
-            delta = float(length_hyp - length_ref)
-            # measure consine similarity
-            val = np.array([0.0 for _ in range(self.n)])
-            for n in range(self.n):
-                # ngram
-                for (ngram,count) in vec_hyp[n].items():
-                    # vrama91 : added clipping
-                    val[n] += min(vec_hyp[n][ngram], vec_ref[n][ngram]) * vec_ref[n][ngram]
-
-                if (norm_hyp[n] != 0) and (norm_ref[n] != 0):
-                    val[n] /= (norm_hyp[n]*norm_ref[n])
-
-                assert(not math.isnan(val[n]))
-                # vrama91: added a length based gaussian penalty
-                val[n] *= np.e**(-(delta**2)/(2*self.sigma**2))
-            return val
-
-        # compute log reference length
-        if self.df_mode == "corpus":
-            self.ref_len = np.log(float(len(self.crefs)))
-        #elif self.df_mode == "coco-val-df":
-            # if coco option selected, use length of coco-val set
-        #    self.ref_len = np.log(float(40504))
-
-        scores = []
-        for test, refs in zip(self.ctest, self.crefs):
-            # compute vector for test captions
-            vec, norm, length = counts2vec(test)
-            # compute vector for ref captions
-            score = np.array([0.0 for _ in range(self.n)])
-            for ref in refs:
-                vec_ref, norm_ref, length_ref = counts2vec(ref)
-                score += sim(vec, vec_ref, norm, norm_ref, length, length_ref)
-            # change by vrama91 - mean of ngram scores, instead of sum
-            score_avg = np.mean(score)
-            # divide by number of references
-            score_avg /= len(refs)
-            # multiply score by 10
-            score_avg *= 10.0
-            # append score of an image to the score list
-            scores.append(score_avg)
-        return scores
-
-    def compute_score(self, option=None, verbose=0):
-        # compute idf
-        if self.df_mode == "corpus":
-            self.document_frequency = defaultdict(float)
-            self.compute_doc_freq()
-            # assert to check document frequency
-            assert(len(self.ctest) >= max(self.document_frequency.values()))
-            # import json for now and write the corresponding files
-        # compute cider score
-        score = self.compute_cider()
-        # debug
-        # print score
-        return np.mean(np.array(score)), np.array(score)
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/show_wer.sh b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/show_wer.sh
deleted file mode 100644
index 9ecf1690c67f8a019009ef32d973fbd45b56c7ca..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/show_wer.sh
+++ /dev/null
@@ -1,52 +0,0 @@
-#!/bin/bash
-
-split="dev_other"
-ref_data=""
-get_best_wer=true
-dec_name="decode"
-graph_name="graph"
-
-. ./cmd.sh
-. ./path.sh
-. parse_options.sh
-
-exp_root=$1
-
-set -eu
-
-echo "==== WER w.r.t. pseudo transcript"
-for x in $exp_root/*/${dec_name}_${split}*; do grep WER $x/wer_* 2>/dev/null | utils/best_wer.sh; done
-
-
-if [ ! -z $ref_data ]; then
-  echo "==== WER w.r.t. real transcript (select based on pseudo WER)"
-  ref_txt=$ref_data/$split/text
-  for x in $exp_root/*/${dec_name}_${split}*; do
-    lang=$(dirname $x)/$graph_name
-
-    lmwt=$(
-      grep WER $x/wer_* 2>/dev/null | utils/best_wer.sh |
-      sed 's/.*wer_\(.*\)$/\1/g' | sed 's/_/./g'
-    )
-    tra=$x/scoring/$lmwt.tra
-    cat $tra | utils/int2sym.pl -f 2- $lang/words.txt | sed 's:<UNK>::g' | sed 's:<SIL>::g' | \
-      compute-wer --text --mode=present \
-      ark:$ref_txt  ark,p:- 2> /dev/null | grep WER | xargs -I{} echo {} $tra
-  done
-fi
-
-if [ ! -z $ref_data ] && $get_best_wer; then
-  echo "==== WER w.r.t. real transcript (select based on true WER)"
-  ref_txt=$ref_data/$split/text
-  for x in $exp_root/*/${dec_name}_${split}*; do
-    lang=$(dirname $x)/$graph_name
-
-    for tra in $x/scoring/*.tra; do
-      cat $tra | utils/int2sym.pl -f 2- $lang/words.txt | sed 's:<UNK>::g' | sed 's:<SIL>::g' | \
-        compute-wer --text --mode=present \
-        ark:$ref_txt  ark,p:- 2> /dev/null | grep WER | xargs -I{} echo {} $tra
-    done | sort -k2n | head -n1
-  done
-fi
-
-exit 0;
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/models/nat/iterative_nonautoregressive_transformer.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/models/nat/iterative_nonautoregressive_transformer.py
deleted file mode 100644
index bc39509980a80eb8c21e0bfdb304649ad3acc4d0..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/models/nat/iterative_nonautoregressive_transformer.py
+++ /dev/null
@@ -1,228 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import torch
-from fairseq.models import register_model, register_model_architecture
-from fairseq.models.nat import NATransformerModel
-
-
-def _sequential_poisoning(s, V, beta=0.33, bos=2, eos=3, pad=1):
-    # s: input batch
-    # V: vocabulary size
-    rand_words = torch.randint(low=4, high=V, size=s.size(), device=s.device)
-    choices = torch.rand(size=s.size(), device=s.device)
-    choices.masked_fill_((s == pad) | (s == bos) | (s == eos), 1)
-
-    replace = choices < beta / 3
-    repeat = (choices >= beta / 3) & (choices < beta * 2 / 3)
-    swap = (choices >= beta * 2 / 3) & (choices < beta)
-    safe = choices >= beta
-
-    for i in range(s.size(1) - 1):
-        rand_word = rand_words[:, i]
-        next_word = s[:, i + 1]
-        self_word = s[:, i]
-
-        replace_i = replace[:, i]
-        swap_i = swap[:, i] & (next_word != 3)
-        repeat_i = repeat[:, i] & (next_word != 3)
-        safe_i = safe[:, i] | ((next_word == 3) & (~replace_i))
-
-        s[:, i] = (
-            self_word * (safe_i | repeat_i).long()
-            + next_word * swap_i.long()
-            + rand_word * replace_i.long()
-        )
-        s[:, i + 1] = (
-            next_word * (safe_i | replace_i).long()
-            + self_word * (swap_i | repeat_i).long()
-        )
-    return s
-
-
-def gumbel_noise(input, TINY=1e-8):
-    return (
-        input.new_zeros(*input.size())
-        .uniform_()
-        .add_(TINY)
-        .log_()
-        .neg_()
-        .add_(TINY)
-        .log_()
-        .neg_()
-    )
-
-
-@register_model("iterative_nonautoregressive_transformer")
-class IterNATransformerModel(NATransformerModel):
-    @staticmethod
-    def add_args(parser):
-        NATransformerModel.add_args(parser)
-        parser.add_argument(
-            "--train-step",
-            type=int,
-            help="number of refinement iterations during training",
-        )
-        parser.add_argument(
-            "--dae-ratio",
-            type=float,
-            help="the probability of switching to the denoising auto-encoder loss",
-        )
-        parser.add_argument(
-            "--stochastic-approx",
-            action="store_true",
-            help="sampling from the decoder as the inputs for next iteration",
-        )
-
-    @classmethod
-    def build_model(cls, args, task):
-        model = super().build_model(args, task)
-        model.train_step = getattr(args, "train_step", 4)
-        model.dae_ratio = getattr(args, "dae_ratio", 0.5)
-        model.stochastic_approx = getattr(args, "stochastic_approx", False)
-        return model
-
-    def forward(
-        self, src_tokens, src_lengths, prev_output_tokens, tgt_tokens, **kwargs
-    ):
-
-        B, T = prev_output_tokens.size()
-
-        # encoding
-        encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs)
-
-        # length prediction
-        length_out = self.decoder.forward_length(
-            normalize=False, encoder_out=encoder_out
-        )
-        length_tgt = self.decoder.forward_length_prediction(
-            length_out, encoder_out, tgt_tokens
-        )
-
-        # decoding
-        word_ins_outs, word_ins_tgts, word_ins_masks = [], [], []
-        for t in range(self.train_step):
-            word_ins_out = self.decoder(
-                normalize=False,
-                prev_output_tokens=prev_output_tokens,
-                encoder_out=encoder_out,
-                step=t,
-            )
-            word_ins_tgt = tgt_tokens
-            word_ins_mask = word_ins_tgt.ne(self.pad)
-
-            word_ins_outs.append(word_ins_out)
-            word_ins_tgts.append(word_ins_tgt)
-            word_ins_masks.append(word_ins_mask)
-
-            if t < (self.train_step - 1):
-                # prediction for next iteration
-                if self.stochastic_approx:
-                    word_ins_prediction = (
-                        word_ins_out + gumbel_noise(word_ins_out)
-                    ).max(-1)[1]
-                else:
-                    word_ins_prediction = word_ins_out.max(-1)[1]
-
-                prev_output_tokens = prev_output_tokens.masked_scatter(
-                    word_ins_mask, word_ins_prediction[word_ins_mask]
-                )
-
-                if self.dae_ratio > 0:
-                    # we do not perform denoising for the first iteration
-                    corrputed = (
-                        torch.rand(size=(B,), device=prev_output_tokens.device)
-                        < self.dae_ratio
-                    )
-                    corrputed_tokens = _sequential_poisoning(
-                        tgt_tokens[corrputed],
-                        len(self.tgt_dict),
-                        0.33,
-                        self.bos,
-                        self.eos,
-                        self.pad,
-                    )
-                    prev_output_tokens[corrputed] = corrputed_tokens
-
-        # concat everything
-        word_ins_out = torch.cat(word_ins_outs, 0)
-        word_ins_tgt = torch.cat(word_ins_tgts, 0)
-        word_ins_mask = torch.cat(word_ins_masks, 0)
-
-        return {
-            "word_ins": {
-                "out": word_ins_out,
-                "tgt": word_ins_tgt,
-                "mask": word_ins_mask,
-                "ls": self.args.label_smoothing,
-                "nll_loss": True,
-            },
-            "length": {
-                "out": length_out,
-                "tgt": length_tgt,
-                "factor": self.decoder.length_loss_factor,
-            },
-        }
-
-
-@register_model_architecture(
-    "iterative_nonautoregressive_transformer", "iterative_nonautoregressive_transformer"
-)
-def inat_base_architecture(args):
-    args.encoder_embed_path = getattr(args, "encoder_embed_path", None)
-    args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512)
-    args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048)
-    args.encoder_layers = getattr(args, "encoder_layers", 6)
-    args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8)
-    args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False)
-    args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False)
-    args.decoder_embed_path = getattr(args, "decoder_embed_path", None)
-    args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim)
-    args.decoder_ffn_embed_dim = getattr(
-        args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim
-    )
-    args.decoder_layers = getattr(args, "decoder_layers", 6)
-    args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8)
-    args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False)
-    args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False)
-    args.attention_dropout = getattr(args, "attention_dropout", 0.0)
-    args.activation_dropout = getattr(args, "activation_dropout", 0.0)
-    args.activation_fn = getattr(args, "activation_fn", "relu")
-    args.dropout = getattr(args, "dropout", 0.1)
-    args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None)
-    args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0)
-    args.share_decoder_input_output_embed = getattr(
-        args, "share_decoder_input_output_embed", False
-    )
-    args.share_all_embeddings = getattr(args, "share_all_embeddings", False)
-    args.no_token_positional_embeddings = getattr(
-        args, "no_token_positional_embeddings", False
-    )
-    args.adaptive_input = getattr(args, "adaptive_input", False)
-    args.apply_bert_init = getattr(args, "apply_bert_init", False)
-
-    args.decoder_output_dim = getattr(
-        args, "decoder_output_dim", args.decoder_embed_dim
-    )
-    args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim)
-
-    # --- special arguments ---
-    args.sg_length_pred = getattr(args, "sg_length_pred", False)
-    args.pred_length_offset = getattr(args, "pred_length_offset", False)
-    args.length_loss_factor = getattr(args, "length_loss_factor", 0.1)
-    args.ngram_predictor = getattr(args, "ngram_predictor", 1)
-    args.src_embedding_copy = getattr(args, "src_embedding_copy", False)
-
-    args.train_step = getattr(args, "train_step", 4)
-    args.dae_ratio = getattr(args, "dae_ratio", 0.5)
-    args.stochastic_approx = getattr(args, "stochastic_approx", False)
-
-
-@register_model_architecture(
-    "iterative_nonautoregressive_transformer",
-    "iterative_nonautoregressive_transformer_wmt_en_de",
-)
-def iter_nat_wmt_en_de(args):
-    inat_base_architecture(args)
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/tests/distributed/test_utils.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/tests/distributed/test_utils.py
deleted file mode 100644
index 30f995b67acd39af5816d2eb412d6b4df7f44f8c..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/tests/distributed/test_utils.py
+++ /dev/null
@@ -1,124 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import functools
-import sys
-import unittest
-
-import torch
-
-from fairseq.distributed import utils as dist_utils
-
-from .utils import objects_are_equal, spawn_and_init
-
-
-class DistributedTest(unittest.TestCase):
-    def setUp(self):
-        if not torch.cuda.is_available():
-            raise unittest.SkipTest("CUDA not available, skipping test")
-        if sys.platform == "win32":
-            raise unittest.SkipTest("NCCL doesn't support Windows, skipping test")
-        if torch.cuda.device_count() < 2:
-            raise unittest.SkipTest("distributed tests require 2+ GPUs, skipping")
-
-
-class TestBroadcastObject(DistributedTest):
-    def test_str(self):
-        spawn_and_init(
-            functools.partial(
-                TestBroadcastObject._test_broadcast_object, "hello world"
-            ),
-            world_size=2,
-        )
-
-    def test_tensor(self):
-        spawn_and_init(
-            functools.partial(
-                TestBroadcastObject._test_broadcast_object,
-                torch.rand(5),
-            ),
-            world_size=2,
-        )
-
-    def test_complex(self):
-        spawn_and_init(
-            functools.partial(
-                TestBroadcastObject._test_broadcast_object,
-                {
-                    "a": "1",
-                    "b": [2, torch.rand(2, 3), 3],
-                    "c": (torch.rand(2, 3), 4),
-                    "d": {5, torch.rand(5)},
-                    "e": torch.rand(5),
-                    "f": torch.rand(5).int().cuda(),
-                },
-            ),
-            world_size=2,
-        )
-
-    @staticmethod
-    def _test_broadcast_object(ref_obj, rank, group):
-        obj = dist_utils.broadcast_object(
-            ref_obj if rank == 0 else None, src_rank=0, group=group
-        )
-        assert objects_are_equal(ref_obj, obj)
-
-
-class TestAllGatherList(DistributedTest):
-    def test_str_equality(self):
-        spawn_and_init(
-            functools.partial(
-                TestAllGatherList._test_all_gather_list_equality,
-                "hello world",
-            ),
-            world_size=2,
-        )
-
-    def test_tensor_equality(self):
-        spawn_and_init(
-            functools.partial(
-                TestAllGatherList._test_all_gather_list_equality,
-                torch.rand(5),
-            ),
-            world_size=2,
-        )
-
-    def test_complex_equality(self):
-        spawn_and_init(
-            functools.partial(
-                TestAllGatherList._test_all_gather_list_equality,
-                {
-                    "a": "1",
-                    "b": [2, torch.rand(2, 3), 3],
-                    "c": (torch.rand(2, 3), 4),
-                    "d": {5, torch.rand(5)},
-                    "e": torch.rand(5),
-                    "f": torch.rand(5).int(),
-                },
-            ),
-            world_size=2,
-        )
-
-    @staticmethod
-    def _test_all_gather_list_equality(ref_obj, rank, group):
-        objs = dist_utils.all_gather_list(ref_obj, group)
-        for obj in objs:
-            assert objects_are_equal(ref_obj, obj)
-
-    def test_rank_tensor(self):
-        spawn_and_init(
-            TestAllGatherList._test_all_gather_list_rank_tensor, world_size=2
-        )
-
-    @staticmethod
-    def _test_all_gather_list_rank_tensor(rank, group):
-        obj = torch.tensor([rank])
-        objs = dist_utils.all_gather_list(obj, group)
-        for i, obj in enumerate(objs):
-            assert obj.item() == i
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/examples/multilingual/data_scripts/check_self_overlaps.py b/spaces/OFA-Sys/OFA-vqa/fairseq/examples/multilingual/data_scripts/check_self_overlaps.py
deleted file mode 100644
index 07b338dcfd2d7f10317608274631d0edd93ba889..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/examples/multilingual/data_scripts/check_self_overlaps.py
+++ /dev/null
@@ -1,103 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-
-import os
-import glob
-import argparse
-from utils.dedup import deup
-import sys
-
-WORKDIR_ROOT = os.environ.get('WORKDIR_ROOT', None)
-
-if WORKDIR_ROOT is None or  not WORKDIR_ROOT.strip():
-    print('please specify your working directory root in OS environment variable WORKDIR_ROOT. Exitting..."')
-    sys.exit(-1)
-
-def get_directions(folder):
-    raw_files = glob.glob(f'{folder}/train*')
-    directions = [os.path.split(file_path)[-1].split('.')[1] for file_path in raw_files] 
-    return directions   
-
-def diff_list(lhs, rhs):
-    return set(lhs).difference(set(rhs))
-
-def check_diff(
-    from_src_file, from_tgt_file, 
-    to_src_file, to_tgt_file, 
-):
-    seen_in_from = set()
-    seen_src_in_from = set()
-    seen_tgt_in_from = set()
-    from_count = 0
-    with open(from_src_file, encoding='utf-8') as fsrc, \
-        open(from_tgt_file, encoding='utf-8') as ftgt:
-        for s, t in zip(fsrc, ftgt):
-            seen_in_from.add((s, t))
-            seen_src_in_from.add(s)
-            seen_tgt_in_from.add(t)
-            from_count += 1
-    common = 0
-    common_src = 0
-    common_tgt = 0
-    to_count = 0
-    seen = set()
-
-    with open(to_src_file, encoding='utf-8') as fsrc, \
-        open(to_tgt_file, encoding='utf-8') as ftgt:
-        for s, t in zip(fsrc, ftgt):
-            to_count += 1
-            if (s, t) not in seen:
-                if (s, t) in seen_in_from:
-                    common += 1
-                if s in seen_src_in_from:
-                    common_src += 1
-                    seen_src_in_from.remove(s)
-                if t in seen_tgt_in_from:
-                    common_tgt += 1
-                    seen_tgt_in_from.remove(t)
-                seen.add((s, t))
-    return common, common_src, common_tgt, from_count, to_count
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--folder", type=str, required=True,
-                        help="the data folder ")
-    parser.add_argument("--split", type=str, default='test',
-                        help="split (valid, test) to check against training data")
-    parser.add_argument('--directions', type=str, default=None, required=False)
-
-    args = parser.parse_args()    
-
-    if args.directions is None:
-        directions = set(get_directions(args.folder))
-        directions = sorted(directions)
-    else:
-        directions = args.directions.split(',')
-    directions = sorted(set(directions))
-
-    results = []
-    print(f'checking where {args.split} split data are in training')
-    print(f'direction\tcommon_count\tsrc common\ttgt common\tfrom_size\tto_size')
-
-    for direction in directions:
-        src, tgt = direction.split('-')
-        from_src_file = f'{args.folder}/{args.split}.{src}-{tgt}.{src}'
-        from_tgt_file = f'{args.folder}/{args.split}.{src}-{tgt}.{tgt}'
-        if not os.path.exists(from_src_file):
-            # some test/valid data might in reverse directinos:
-            from_src_file = f'{args.folder}/{args.split}.{tgt}-{src}.{src}'
-            from_tgt_file = f'{args.folder}/{args.split}.{tgt}-{src}.{tgt}'            
-        to_src_file = f'{args.folder}/train.{src}-{tgt}.{src}'
-        to_tgt_file = f'{args.folder}/train.{src}-{tgt}.{tgt}'
-        if not os.path.exists(to_src_file) or not os.path.exists(from_src_file):
-            continue
-        r = check_diff(from_src_file, from_tgt_file, to_src_file, to_tgt_file)
-        results.append(r)
-        print(f'{direction}\t', '\t'.join(map(str, r)))
-                
-
-if __name__ == "__main__":
-    main()
diff --git a/spaces/Olivier-Truong/faster-whisper-webui-v2/src/utils.py b/spaces/Olivier-Truong/faster-whisper-webui-v2/src/utils.py
deleted file mode 100644
index f67fbef98d97c220156ae39659de1552a7bcc015..0000000000000000000000000000000000000000
--- a/spaces/Olivier-Truong/faster-whisper-webui-v2/src/utils.py
+++ /dev/null
@@ -1,262 +0,0 @@
-import textwrap
-import unicodedata
-import re
-
-import zlib
-from typing import Iterator, TextIO, Union
-import tqdm
-
-import urllib3
-
-
-def exact_div(x, y):
-    assert x % y == 0
-    return x // y
-
-
-def str2bool(string):
-    str2val = {"True": True, "False": False}
-    if string in str2val:
-        return str2val[string]
-    else:
-        raise ValueError(f"Expected one of {set(str2val.keys())}, got {string}")
-
-
-def optional_int(string):
-    return None if string == "None" else int(string)
-
-
-def optional_float(string):
-    return None if string == "None" else float(string)
-
-
-def compression_ratio(text) -> float:
-    return len(text) / len(zlib.compress(text.encode("utf-8")))
-
-
-def format_timestamp(seconds: float, always_include_hours: bool = False, fractionalSeperator: str = '.'):
-    assert seconds >= 0, "non-negative timestamp expected"
-    milliseconds = round(seconds * 1000.0)
-
-    hours = milliseconds // 3_600_000
-    milliseconds -= hours * 3_600_000
-
-    minutes = milliseconds // 60_000
-    milliseconds -= minutes * 60_000
-
-    seconds = milliseconds // 1_000
-    milliseconds -= seconds * 1_000
-
-    hours_marker = f"{hours:02d}:" if always_include_hours or hours > 0 else ""
-    return f"{hours_marker}{minutes:02d}:{seconds:02d}{fractionalSeperator}{milliseconds:03d}"
-
-
-def write_txt(transcript: Iterator[dict], file: TextIO):
-    for segment in transcript:
-        print(segment['text'].strip(), file=file, flush=True)
-
-
-def write_vtt(transcript: Iterator[dict], file: TextIO, 
-              maxLineWidth=None, highlight_words: bool = False):
-    iterator  = __subtitle_preprocessor_iterator(transcript, maxLineWidth, highlight_words)
-
-    print("WEBVTT\n", file=file)
-
-    for segment in iterator:
-        text = segment['text'].replace('-->', '->')
-
-        print(
-            f"{format_timestamp(segment['start'])} --> {format_timestamp(segment['end'])}\n"
-            f"{text}\n",
-            file=file,
-            flush=True,
-        )
-
-def write_srt(transcript: Iterator[dict], file: TextIO, 
-              maxLineWidth=None, highlight_words: bool = False):
-    """
-    Write a transcript to a file in SRT format.
-    Example usage:
-        from pathlib import Path
-        from whisper.utils import write_srt
-        result = transcribe(model, audio_path, temperature=temperature, **args)
-        # save SRT
-        audio_basename = Path(audio_path).stem
-        with open(Path(output_dir) / (audio_basename + ".srt"), "w", encoding="utf-8") as srt:
-            write_srt(result["segments"], file=srt)
-    """
-    iterator  = __subtitle_preprocessor_iterator(transcript, maxLineWidth, highlight_words)
-
-    for i, segment in enumerate(iterator, start=1):
-        text = segment['text'].replace('-->', '->')
-
-        # write srt lines
-        print(
-            f"{i}\n"
-            f"{format_timestamp(segment['start'], always_include_hours=True, fractionalSeperator=',')} --> "
-            f"{format_timestamp(segment['end'], always_include_hours=True, fractionalSeperator=',')}\n"
-            f"{text}\n",
-            file=file,
-            flush=True,
-        )
-
-def __subtitle_preprocessor_iterator(transcript: Iterator[dict], maxLineWidth: int = None, highlight_words: bool = False): 
-    for segment in transcript:
-        words: list = segment.get('words', [])
-
-        # Append longest speaker ID if available
-        segment_longest_speaker = segment.get('longest_speaker', None)
-
-        if len(words) == 0:
-            # Yield the segment as-is or processed
-            if (maxLineWidth is None or maxLineWidth < 0) and segment_longest_speaker is None:
-                yield segment
-            else:
-                text = segment['text'].strip()
-
-                # Prepend the longest speaker ID if available
-                if segment_longest_speaker is not None:
-                    text = f"({segment_longest_speaker}) {text}"
-
-                yield {
-                    'start': segment['start'],
-                    'end': segment['end'],
-                    'text': process_text(text, maxLineWidth)
-                }
-            # We are done
-            continue
-
-        subtitle_start = segment['start']
-        subtitle_end = segment['end']
-
-        if segment_longest_speaker is not None:
-            # Add the beginning
-            words.insert(0, {
-                'start': subtitle_start,
-                'end': subtitle_start,
-                'word': f"({segment_longest_speaker})"
-            })
-
-        text_words = [ this_word["word"] for this_word in words ]
-        subtitle_text = __join_words(text_words, maxLineWidth)
-
-        # Iterate over the words in the segment
-        if highlight_words:
-            last = subtitle_start
-
-            for i, this_word in enumerate(words):
-                start = this_word['start']
-                end = this_word['end']
-
-                if last != start:
-                    # Display the text up to this point
-                    yield {
-                        'start': last,
-                        'end': start,
-                        'text': subtitle_text
-                    }
-                
-                # Display the text with the current word highlighted
-                yield {
-                    'start': start,
-                    'end': end,
-                    'text': __join_words(
-                        [
-                            {
-                                "word": re.sub(r"^(\s*)(.*)$", r"\1<u>\2</u>", word)
-                                        if j == i
-                                        else word,
-                                # The HTML tags <u> and </u> are not displayed, 
-                                # # so they should not be counted in the word length
-                                "length": len(word)
-                            } for j, word in enumerate(text_words)
-                        ], maxLineWidth)
-                }
-                last = end
-
-            if last != subtitle_end:
-                # Display the last part of the text
-                yield {
-                    'start': last,
-                    'end': subtitle_end,
-                    'text': subtitle_text
-                }
-
-        # Just return the subtitle text
-        else:
-            yield {
-                'start': subtitle_start,
-                'end': subtitle_end,
-                'text': subtitle_text
-            }
-
-def __join_words(words: Iterator[Union[str, dict]], maxLineWidth: int = None):
-    if maxLineWidth is None or maxLineWidth < 0:
-        return " ".join(words)
-    
-    lines = []
-    current_line = ""
-    current_length = 0
-
-    for entry in words:
-        # Either accept a string or a dict with a 'word' and 'length' field
-        if isinstance(entry, dict):
-            word = entry['word']
-            word_length = entry['length']
-        else:
-            word = entry
-            word_length = len(word)
-
-        if current_length > 0 and current_length + word_length > maxLineWidth:
-            lines.append(current_line)
-            current_line = ""
-            current_length = 0
-        
-        current_length += word_length
-        # The word will be prefixed with a space by Whisper, so we don't need to add one here
-        current_line += word
-
-    if len(current_line) > 0:
-        lines.append(current_line)
-
-    return "\n".join(lines)
-
-def process_text(text: str, maxLineWidth=None):
-    if (maxLineWidth is None or maxLineWidth < 0):
-        return text
-
-    lines = textwrap.wrap(text, width=maxLineWidth, tabsize=4)
-    return '\n'.join(lines)
-
-def slugify(value, allow_unicode=False):
-    """
-    Taken from https://github.com/django/django/blob/master/django/utils/text.py
-    Convert to ASCII if 'allow_unicode' is False. Convert spaces or repeated
-    dashes to single dashes. Remove characters that aren't alphanumerics,
-    underscores, or hyphens. Convert to lowercase. Also strip leading and
-    trailing whitespace, dashes, and underscores.
-    """
-    value = str(value)
-    if allow_unicode:
-        value = unicodedata.normalize('NFKC', value)
-    else:
-        value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore').decode('ascii')
-    value = re.sub(r'[^\w\s-]', '', value.lower())
-    return re.sub(r'[-\s]+', '-', value).strip('-_')
-
-def download_file(url: str, destination: str):
-        with urllib3.request.urlopen(url) as source, open(destination, "wb") as output:
-            with tqdm(
-                total=int(source.info().get("Content-Length")),
-                ncols=80,
-                unit="iB",
-                unit_scale=True,
-                unit_divisor=1024,
-            ) as loop:
-                while True:
-                    buffer = source.read(8192)
-                    if not buffer:
-                        break
-
-                    output.write(buffer)
-                    loop.update(len(buffer))
\ No newline at end of file
diff --git a/spaces/Olivier-Truong/faster-whisper-webui-v2/src/whisper/whisperContainer.py b/spaces/Olivier-Truong/faster-whisper-webui-v2/src/whisper/whisperContainer.py
deleted file mode 100644
index 7826d28aa3e6b345febdbd1e6297b4bba9e7fbdc..0000000000000000000000000000000000000000
--- a/spaces/Olivier-Truong/faster-whisper-webui-v2/src/whisper/whisperContainer.py
+++ /dev/null
@@ -1,216 +0,0 @@
-# External programs
-import abc
-import os
-import sys
-from typing import List
-from urllib.parse import urlparse
-import torch
-import urllib3
-from src.hooks.progressListener import ProgressListener
-
-import whisper
-from whisper import Whisper
-
-from src.config import ModelConfig, VadInitialPromptMode
-from src.hooks.whisperProgressHook import create_progress_listener_handle
-
-from src.modelCache import GLOBAL_MODEL_CACHE, ModelCache
-from src.prompts.abstractPromptStrategy import AbstractPromptStrategy
-from src.utils import download_file
-from src.whisper.abstractWhisperContainer import AbstractWhisperCallback, AbstractWhisperContainer
-
-class WhisperContainer(AbstractWhisperContainer):
-    def __init__(self, model_name: str, device: str = None, compute_type: str = "float16",
-                 download_root: str = None,
-                 cache: ModelCache = None, models: List[ModelConfig] = []):
-        if device is None:
-            device = "cuda" if torch.cuda.is_available() else "cpu"
-        super().__init__(model_name, device, compute_type, download_root, cache, models)
-    
-    def ensure_downloaded(self):
-        """
-        Ensure that the model is downloaded. This is useful if you want to ensure that the model is downloaded before
-        passing the container to a subprocess.
-        """
-        # Warning: Using private API here
-        try:
-            root_dir = self.download_root
-            model_config = self._get_model_config()
-
-            if root_dir is None:
-                root_dir = os.path.join(os.path.expanduser("~"), ".cache", "whisper")
-
-            if self.model_name in whisper._MODELS:
-                whisper._download(whisper._MODELS[self.model_name], root_dir, False)
-            else:
-                # If the model is not in the official list, see if it needs to be downloaded
-                model_config.download_url(root_dir)
-            return True
-        
-        except Exception as e:
-            # Given that the API is private, it could change at any time. We don't want to crash the program
-            print("Error pre-downloading model: " + str(e))
-            return False
-
-    def _get_model_config(self) -> ModelConfig:
-        """
-        Get the model configuration for the model.
-        """
-        for model in self.models:
-            if model.name == self.model_name:
-                return model
-        return None
-
-    def _create_model(self):
-        print("Loading whisper model " + self.model_name)
-        model_config = self._get_model_config()
-
-        # Note that the model will not be downloaded in the case of an official Whisper model
-        model_path = self._get_model_path(model_config, self.download_root)
-
-        return whisper.load_model(model_path, device=self.device, download_root=self.download_root)
-
-    def create_callback(self, language: str = None, task: str = None, 
-                        prompt_strategy: AbstractPromptStrategy = None,
-                        **decodeOptions: dict) -> AbstractWhisperCallback:
-        """
-        Create a WhisperCallback object that can be used to transcript audio files.
-
-        Parameters
-        ----------
-        language: str
-            The target language of the transcription. If not specified, the language will be inferred from the audio content.
-        task: str
-            The task - either translate or transcribe.
-        prompt_strategy: AbstractPromptStrategy
-            The prompt strategy to use. If not specified, the prompt from Whisper will be used.
-        decodeOptions: dict
-            Additional options to pass to the decoder. Must be pickleable.
-
-        Returns
-        -------
-        A WhisperCallback object.
-        """
-        return WhisperCallback(self, language=language, task=task, prompt_strategy=prompt_strategy, **decodeOptions)
-
-    def _get_model_path(self, model_config: ModelConfig, root_dir: str = None):
-        from src.conversion.hf_converter import convert_hf_whisper
-        """
-        Download the model.
-
-        Parameters
-        ----------
-        model_config: ModelConfig
-            The model configuration.
-        """
-        # See if path is already set
-        if model_config.path is not None:
-            return model_config.path
-        
-        if root_dir is None:
-            root_dir = os.path.join(os.path.expanduser("~"), ".cache", "whisper")
-
-        model_type = model_config.type.lower() if model_config.type is not None else "whisper"
-
-        if model_type in ["huggingface", "hf"]:
-            model_config.path = model_config.url
-            destination_target = os.path.join(root_dir, model_config.name + ".pt")
-
-            # Convert from HuggingFace format to Whisper format
-            if os.path.exists(destination_target):
-                print(f"File {destination_target} already exists, skipping conversion")
-            else:
-                print("Saving HuggingFace model in Whisper format to " + destination_target)
-                convert_hf_whisper(model_config.url, destination_target)
-
-            model_config.path = destination_target
-
-        elif model_type in ["whisper", "w"]:
-            model_config.path = model_config.url
-
-            # See if URL is just a file
-            if model_config.url in whisper._MODELS:
-                # No need to download anything - Whisper will handle it
-                model_config.path = model_config.url
-            elif model_config.url.startswith("file://"):
-                # Get file path
-                model_config.path = urlparse(model_config.url).path
-            # See if it is an URL
-            elif model_config.url.startswith("http://") or model_config.url.startswith("https://"):
-                # Extension (or file name)
-                extension = os.path.splitext(model_config.url)[-1]
-                download_target = os.path.join(root_dir, model_config.name + extension)
-
-                if os.path.exists(download_target) and not os.path.isfile(download_target):
-                    raise RuntimeError(f"{download_target} exists and is not a regular file")
-
-                if not os.path.isfile(download_target):
-                    download_file(model_config.url, download_target)
-                else:
-                    print(f"File {download_target} already exists, skipping download")
-
-                model_config.path = download_target
-            # Must be a local file
-            else:
-                model_config.path = model_config.url
-
-        else:
-            raise ValueError(f"Unknown model type {model_type}")
-
-        return model_config.path
-
-class WhisperCallback(AbstractWhisperCallback):
-    def __init__(self, model_container: WhisperContainer, language: str = None, task: str = None, 
-                 prompt_strategy: AbstractPromptStrategy = None, 
-                 **decodeOptions: dict):
-        self.model_container = model_container
-        self.language = language
-        self.task = task
-        self.prompt_strategy = prompt_strategy
-
-        self.decodeOptions = decodeOptions
-        
-    def invoke(self, audio, segment_index: int, prompt: str, detected_language: str, progress_listener: ProgressListener = None):
-        """
-        Peform the transcription of the given audio file or data.
-
-        Parameters
-        ----------
-        audio: Union[str, np.ndarray, torch.Tensor]
-            The audio file to transcribe, or the audio data as a numpy array or torch tensor.
-        segment_index: int
-            The target language of the transcription. If not specified, the language will be inferred from the audio content.
-        task: str
-            The task - either translate or transcribe.
-        progress_listener: ProgressListener
-            A callback to receive progress updates.
-        """
-        model = self.model_container.get_model()
-
-        if progress_listener is not None:
-            with create_progress_listener_handle(progress_listener):
-                return self._transcribe(model, audio, segment_index, prompt, detected_language)
-        else:
-            return self._transcribe(model, audio, segment_index, prompt, detected_language)
-    
-    def _transcribe(self, model: Whisper, audio, segment_index: int, prompt: str, detected_language: str):
-        decodeOptions = self.decodeOptions.copy()
-
-        # Add fp16
-        if self.model_container.compute_type in ["fp16", "float16"]:
-            decodeOptions["fp16"] = True
-
-        initial_prompt = self.prompt_strategy.get_segment_prompt(segment_index, prompt, detected_language) \
-                           if self.prompt_strategy else prompt
-
-        result = model.transcribe(audio, \
-            language=self.language if self.language else detected_language, task=self.task, \
-            initial_prompt=initial_prompt, \
-            **decodeOptions
-        )
-
-        # If we have a prompt strategy, we need to increment the current prompt
-        if self.prompt_strategy:
-            self.prompt_strategy.on_segment_finished(segment_index, prompt, detected_language, result)
-
-        return result
\ No newline at end of file
diff --git a/spaces/OllieWallie/Openai/Dockerfile b/spaces/OllieWallie/Openai/Dockerfile
deleted file mode 100644
index 6c01c09373883afcb4ea34ae2d316cd596e1737b..0000000000000000000000000000000000000000
--- a/spaces/OllieWallie/Openai/Dockerfile
+++ /dev/null
@@ -1,21 +0,0 @@
-FROM node:18-bullseye-slim
-
-RUN apt-get update && \
-
-apt-get install -y git
-
-RUN git clone https://gitgud.io/khanon/oai-reverse-proxy.git /app
-
-WORKDIR /app
-
-RUN npm install
-
-COPY Dockerfile greeting.md* .env* ./
-
-RUN npm run build
-
-EXPOSE 7860
-
-ENV NODE_ENV=production
-
-CMD [ "npm", "start" ]
\ No newline at end of file
diff --git a/spaces/OpenMotionLab/MotionGPT/mGPT/models/utils/adain.py b/spaces/OpenMotionLab/MotionGPT/mGPT/models/utils/adain.py
deleted file mode 100644
index 3588f33e19fa3434ee2801f941c40566923abf41..0000000000000000000000000000000000000000
--- a/spaces/OpenMotionLab/MotionGPT/mGPT/models/utils/adain.py
+++ /dev/null
@@ -1,66 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-class AdaptiveInstanceNorm1d(nn.Module):
-    def __init__(self, num_features, eps=1e-5, momentum=0.1):
-        super(AdaptiveInstanceNorm1d, self).__init__()
-        self.num_features = num_features
-        self.eps = eps
-        self.momentum = momentum
-        self.weight = None
-        self.bias = None
-        self.register_buffer('running_mean', torch.zeros(num_features))
-        self.register_buffer('running_var', torch.ones(num_features))
-
-    def forward(self, x, direct_weighting=False, no_std=False):
-        assert self.weight is not None and \
-               self.bias is not None, "Please assign AdaIN weight first"
-        # (bs, nfeats, nframe) <= (nframe, bs, nfeats)
-        x = x.permute(1,2,0) 
-
-        b, c = x.size(0), x.size(1)  # batch size & channels
-        running_mean = self.running_mean.repeat(b)
-        running_var = self.running_var.repeat(b)
-        # self.weight = torch.ones_like(self.weight)
-
-        if direct_weighting:
-            x_reshaped = x.contiguous().view(b * c)
-            if no_std:
-                out = x_reshaped + self.bias
-            else:
-                out = x_reshaped.mul(self.weight) + self.bias
-            out = out.view(b, c, *x.size()[2:])
-        else:
-            x_reshaped = x.contiguous().view(1, b * c, *x.size()[2:])        
-            out = F.batch_norm(
-                x_reshaped, running_mean, running_var, self.weight, self.bias,
-                True, self.momentum, self.eps)
-            out = out.view(b, c, *x.size()[2:])
-
-        # (nframe, bs, nfeats) <= (bs, nfeats, nframe)
-        out = out.permute(2,0,1) 
-        return out
-
-    def __repr__(self):
-        return self.__class__.__name__ + '(' + str(self.num_features) + ')'
-
-def assign_adain_params(adain_params, model):
-    # assign the adain_params to the AdaIN layers in model
-    for m in model.modules():
-        if m.__class__.__name__ == "AdaptiveInstanceNorm1d":
-            mean = adain_params[: , : m.num_features]
-            std = adain_params[: , m.num_features: 2 * m.num_features]
-            m.bias = mean.contiguous().view(-1)
-            m.weight = std.contiguous().view(-1)
-            if adain_params.size(1) > 2 * m.num_features:
-                adain_params = adain_params[: , 2 * m.num_features:]
-
-
-def get_num_adain_params(model):
-    # return the number of AdaIN parameters needed by the model
-    num_adain_params = 0
-    for m in model.modules():
-        if m.__class__.__name__ == "AdaptiveInstanceNorm1d":
-            num_adain_params += 2 * m.num_features
-    return num_adain_params
diff --git a/spaces/Owechada/roopfaceswapr/roop/processors/__init__.py b/spaces/Owechada/roopfaceswapr/roop/processors/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/cnn/bricks/activation.py b/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/cnn/bricks/activation.py
deleted file mode 100644
index cab2712287d5ef7be2f079dcb54a94b96394eab5..0000000000000000000000000000000000000000
--- a/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/cnn/bricks/activation.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from annotator.uniformer.mmcv.utils import TORCH_VERSION, build_from_cfg, digit_version
-from .registry import ACTIVATION_LAYERS
-
-for module in [
-        nn.ReLU, nn.LeakyReLU, nn.PReLU, nn.RReLU, nn.ReLU6, nn.ELU,
-        nn.Sigmoid, nn.Tanh
-]:
-    ACTIVATION_LAYERS.register_module(module=module)
-
-
-@ACTIVATION_LAYERS.register_module(name='Clip')
-@ACTIVATION_LAYERS.register_module()
-class Clamp(nn.Module):
-    """Clamp activation layer.
-
-    This activation function is to clamp the feature map value within
-    :math:`[min, max]`. More details can be found in ``torch.clamp()``.
-
-    Args:
-        min (Number | optional): Lower-bound of the range to be clamped to.
-            Default to -1.
-        max (Number | optional): Upper-bound of the range to be clamped to.
-            Default to 1.
-    """
-
-    def __init__(self, min=-1., max=1.):
-        super(Clamp, self).__init__()
-        self.min = min
-        self.max = max
-
-    def forward(self, x):
-        """Forward function.
-
-        Args:
-            x (torch.Tensor): The input tensor.
-
-        Returns:
-            torch.Tensor: Clamped tensor.
-        """
-        return torch.clamp(x, min=self.min, max=self.max)
-
-
-class GELU(nn.Module):
-    r"""Applies the Gaussian Error Linear Units function:
-
-    .. math::
-        \text{GELU}(x) = x * \Phi(x)
-    where :math:`\Phi(x)` is the Cumulative Distribution Function for
-    Gaussian Distribution.
-
-    Shape:
-        - Input: :math:`(N, *)` where `*` means, any number of additional
-          dimensions
-        - Output: :math:`(N, *)`, same shape as the input
-
-    .. image:: scripts/activation_images/GELU.png
-
-    Examples::
-
-        >>> m = nn.GELU()
-        >>> input = torch.randn(2)
-        >>> output = m(input)
-    """
-
-    def forward(self, input):
-        return F.gelu(input)
-
-
-if (TORCH_VERSION == 'parrots'
-        or digit_version(TORCH_VERSION) < digit_version('1.4')):
-    ACTIVATION_LAYERS.register_module(module=GELU)
-else:
-    ACTIVATION_LAYERS.register_module(module=nn.GELU)
-
-
-def build_activation_layer(cfg):
-    """Build activation layer.
-
-    Args:
-        cfg (dict): The activation layer config, which should contain:
-            - type (str): Layer type.
-            - layer args: Args needed to instantiate an activation layer.
-
-    Returns:
-        nn.Module: Created activation layer.
-    """
-    return build_from_cfg(cfg, ACTIVATION_LAYERS)
diff --git a/spaces/PSLD/PSLD/stable-diffusion/ldm/modules/losses/vqperceptual.py b/spaces/PSLD/PSLD/stable-diffusion/ldm/modules/losses/vqperceptual.py
deleted file mode 100644
index f69981769e4bd5462600458c4fcf26620f7e4306..0000000000000000000000000000000000000000
--- a/spaces/PSLD/PSLD/stable-diffusion/ldm/modules/losses/vqperceptual.py
+++ /dev/null
@@ -1,167 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-from einops import repeat
-
-from taming.modules.discriminator.model import NLayerDiscriminator, weights_init
-from taming.modules.losses.lpips import LPIPS
-from taming.modules.losses.vqperceptual import hinge_d_loss, vanilla_d_loss
-
-
-def hinge_d_loss_with_exemplar_weights(logits_real, logits_fake, weights):
-    assert weights.shape[0] == logits_real.shape[0] == logits_fake.shape[0]
-    loss_real = torch.mean(F.relu(1. - logits_real), dim=[1,2,3])
-    loss_fake = torch.mean(F.relu(1. + logits_fake), dim=[1,2,3])
-    loss_real = (weights * loss_real).sum() / weights.sum()
-    loss_fake = (weights * loss_fake).sum() / weights.sum()
-    d_loss = 0.5 * (loss_real + loss_fake)
-    return d_loss
-
-def adopt_weight(weight, global_step, threshold=0, value=0.):
-    if global_step < threshold:
-        weight = value
-    return weight
-
-
-def measure_perplexity(predicted_indices, n_embed):
-    # src: https://github.com/karpathy/deep-vector-quantization/blob/main/model.py
-    # eval cluster perplexity. when perplexity == num_embeddings then all clusters are used exactly equally
-    encodings = F.one_hot(predicted_indices, n_embed).float().reshape(-1, n_embed)
-    avg_probs = encodings.mean(0)
-    perplexity = (-(avg_probs * torch.log(avg_probs + 1e-10)).sum()).exp()
-    cluster_use = torch.sum(avg_probs > 0)
-    return perplexity, cluster_use
-
-def l1(x, y):
-    return torch.abs(x-y)
-
-
-def l2(x, y):
-    return torch.pow((x-y), 2)
-
-
-class VQLPIPSWithDiscriminator(nn.Module):
-    def __init__(self, disc_start, codebook_weight=1.0, pixelloss_weight=1.0,
-                 disc_num_layers=3, disc_in_channels=3, disc_factor=1.0, disc_weight=1.0,
-                 perceptual_weight=1.0, use_actnorm=False, disc_conditional=False,
-                 disc_ndf=64, disc_loss="hinge", n_classes=None, perceptual_loss="lpips",
-                 pixel_loss="l1"):
-        super().__init__()
-        assert disc_loss in ["hinge", "vanilla"]
-        assert perceptual_loss in ["lpips", "clips", "dists"]
-        assert pixel_loss in ["l1", "l2"]
-        self.codebook_weight = codebook_weight
-        self.pixel_weight = pixelloss_weight
-        if perceptual_loss == "lpips":
-            print(f"{self.__class__.__name__}: Running with LPIPS.")
-            self.perceptual_loss = LPIPS().eval()
-        else:
-            raise ValueError(f"Unknown perceptual loss: >> {perceptual_loss} <<")
-        self.perceptual_weight = perceptual_weight
-
-        if pixel_loss == "l1":
-            self.pixel_loss = l1
-        else:
-            self.pixel_loss = l2
-
-        self.discriminator = NLayerDiscriminator(input_nc=disc_in_channels,
-                                                 n_layers=disc_num_layers,
-                                                 use_actnorm=use_actnorm,
-                                                 ndf=disc_ndf
-                                                 ).apply(weights_init)
-        self.discriminator_iter_start = disc_start
-        if disc_loss == "hinge":
-            self.disc_loss = hinge_d_loss
-        elif disc_loss == "vanilla":
-            self.disc_loss = vanilla_d_loss
-        else:
-            raise ValueError(f"Unknown GAN loss '{disc_loss}'.")
-        print(f"VQLPIPSWithDiscriminator running with {disc_loss} loss.")
-        self.disc_factor = disc_factor
-        self.discriminator_weight = disc_weight
-        self.disc_conditional = disc_conditional
-        self.n_classes = n_classes
-
-    def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None):
-        if last_layer is not None:
-            nll_grads = torch.autograd.grad(nll_loss, last_layer, retain_graph=True)[0]
-            g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0]
-        else:
-            nll_grads = torch.autograd.grad(nll_loss, self.last_layer[0], retain_graph=True)[0]
-            g_grads = torch.autograd.grad(g_loss, self.last_layer[0], retain_graph=True)[0]
-
-        d_weight = torch.norm(nll_grads) / (torch.norm(g_grads) + 1e-4)
-        d_weight = torch.clamp(d_weight, 0.0, 1e4).detach()
-        d_weight = d_weight * self.discriminator_weight
-        return d_weight
-
-    def forward(self, codebook_loss, inputs, reconstructions, optimizer_idx,
-                global_step, last_layer=None, cond=None, split="train", predicted_indices=None):
-        if not exists(codebook_loss):
-            codebook_loss = torch.tensor([0.]).to(inputs.device)
-        #rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous())
-        rec_loss = self.pixel_loss(inputs.contiguous(), reconstructions.contiguous())
-        if self.perceptual_weight > 0:
-            p_loss = self.perceptual_loss(inputs.contiguous(), reconstructions.contiguous())
-            rec_loss = rec_loss + self.perceptual_weight * p_loss
-        else:
-            p_loss = torch.tensor([0.0])
-
-        nll_loss = rec_loss
-        #nll_loss = torch.sum(nll_loss) / nll_loss.shape[0]
-        nll_loss = torch.mean(nll_loss)
-
-        # now the GAN part
-        if optimizer_idx == 0:
-            # generator update
-            if cond is None:
-                assert not self.disc_conditional
-                logits_fake = self.discriminator(reconstructions.contiguous())
-            else:
-                assert self.disc_conditional
-                logits_fake = self.discriminator(torch.cat((reconstructions.contiguous(), cond), dim=1))
-            g_loss = -torch.mean(logits_fake)
-
-            try:
-                d_weight = self.calculate_adaptive_weight(nll_loss, g_loss, last_layer=last_layer)
-            except RuntimeError:
-                assert not self.training
-                d_weight = torch.tensor(0.0)
-
-            disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start)
-            loss = nll_loss + d_weight * disc_factor * g_loss + self.codebook_weight * codebook_loss.mean()
-
-            log = {"{}/total_loss".format(split): loss.clone().detach().mean(),
-                   "{}/quant_loss".format(split): codebook_loss.detach().mean(),
-                   "{}/nll_loss".format(split): nll_loss.detach().mean(),
-                   "{}/rec_loss".format(split): rec_loss.detach().mean(),
-                   "{}/p_loss".format(split): p_loss.detach().mean(),
-                   "{}/d_weight".format(split): d_weight.detach(),
-                   "{}/disc_factor".format(split): torch.tensor(disc_factor),
-                   "{}/g_loss".format(split): g_loss.detach().mean(),
-                   }
-            if predicted_indices is not None:
-                assert self.n_classes is not None
-                with torch.no_grad():
-                    perplexity, cluster_usage = measure_perplexity(predicted_indices, self.n_classes)
-                log[f"{split}/perplexity"] = perplexity
-                log[f"{split}/cluster_usage"] = cluster_usage
-            return loss, log
-
-        if optimizer_idx == 1:
-            # second pass for discriminator update
-            if cond is None:
-                logits_real = self.discriminator(inputs.contiguous().detach())
-                logits_fake = self.discriminator(reconstructions.contiguous().detach())
-            else:
-                logits_real = self.discriminator(torch.cat((inputs.contiguous().detach(), cond), dim=1))
-                logits_fake = self.discriminator(torch.cat((reconstructions.contiguous().detach(), cond), dim=1))
-
-            disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start)
-            d_loss = disc_factor * self.disc_loss(logits_real, logits_fake)
-
-            log = {"{}/disc_loss".format(split): d_loss.clone().detach().mean(),
-                   "{}/logits_real".format(split): logits_real.detach().mean(),
-                   "{}/logits_fake".format(split): logits_fake.detach().mean()
-                   }
-            return d_loss, log
diff --git a/spaces/PaddlePaddle/animegan_v1_hayao_60/README.md b/spaces/PaddlePaddle/animegan_v1_hayao_60/README.md
deleted file mode 100644
index 51c2149ce24ce99f983eb1bbf7864a9749b0adbf..0000000000000000000000000000000000000000
--- a/spaces/PaddlePaddle/animegan_v1_hayao_60/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Animegan_v1_hayao_60
-emoji: 🚀
-colorFrom: red
-colorTo: pink
-sdk: gradio
-sdk_version: 2.8.8
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/ParityError/LimeFace/README.md b/spaces/ParityError/LimeFace/README.md
deleted file mode 100644
index ed8ddb489b440be16881bee3c2a24a97d34e6c55..0000000000000000000000000000000000000000
--- a/spaces/ParityError/LimeFace/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-
----
-tags: [gradio-theme, track-1, track-4, minimalist-theme, custom-gradio-theme]
-title: LimeFace
-emoji: 🍋
-colorFrom: orange
-colorTo: purple
-sdk: gradio
-sdk_version: 3.24.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-# Limepop
-## Description
-Minimalist Lime + Icy Blue Gradio Theme ~ Enjoy!
-## Contributions
-Thanks to [@ParityError](https://huggingface.co/ParityError) for adding this gradio theme!
diff --git a/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/utils/config.py b/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/utils/config.py
deleted file mode 100644
index 17149353aefac6d737c67bb2f35a3a6cd2147b0a..0000000000000000000000000000000000000000
--- a/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/utils/config.py
+++ /dev/null
@@ -1,688 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import ast
-import copy
-import os
-import os.path as osp
-import platform
-import shutil
-import sys
-import tempfile
-import uuid
-import warnings
-from argparse import Action, ArgumentParser
-from collections import abc
-from importlib import import_module
-
-from addict import Dict
-from yapf.yapflib.yapf_api import FormatCode
-
-from .misc import import_modules_from_strings
-from .path import check_file_exist
-
-if platform.system() == 'Windows':
-    import regex as re
-else:
-    import re
-
-BASE_KEY = '_base_'
-DELETE_KEY = '_delete_'
-DEPRECATION_KEY = '_deprecation_'
-RESERVED_KEYS = ['filename', 'text', 'pretty_text']
-
-
-class ConfigDict(Dict):
-
-    def __missing__(self, name):
-        raise KeyError(name)
-
-    def __getattr__(self, name):
-        try:
-            value = super(ConfigDict, self).__getattr__(name)
-        except KeyError:
-            ex = AttributeError(f"'{self.__class__.__name__}' object has no "
-                                f"attribute '{name}'")
-        except Exception as e:
-            ex = e
-        else:
-            return value
-        raise ex
-
-
-def add_args(parser, cfg, prefix=''):
-    for k, v in cfg.items():
-        if isinstance(v, str):
-            parser.add_argument('--' + prefix + k)
-        elif isinstance(v, int):
-            parser.add_argument('--' + prefix + k, type=int)
-        elif isinstance(v, float):
-            parser.add_argument('--' + prefix + k, type=float)
-        elif isinstance(v, bool):
-            parser.add_argument('--' + prefix + k, action='store_true')
-        elif isinstance(v, dict):
-            add_args(parser, v, prefix + k + '.')
-        elif isinstance(v, abc.Iterable):
-            parser.add_argument('--' + prefix + k, type=type(v[0]), nargs='+')
-        else:
-            print(f'cannot parse key {prefix + k} of type {type(v)}')
-    return parser
-
-
-class Config:
-    """A facility for config and config files.
-
-    It supports common file formats as configs: python/json/yaml. The interface
-    is the same as a dict object and also allows access config values as
-    attributes.
-
-    Example:
-        >>> cfg = Config(dict(a=1, b=dict(b1=[0, 1])))
-        >>> cfg.a
-        1
-        >>> cfg.b
-        {'b1': [0, 1]}
-        >>> cfg.b.b1
-        [0, 1]
-        >>> cfg = Config.fromfile('tests/data/config/a.py')
-        >>> cfg.filename
-        "/home/kchen/projects/mmcv/tests/data/config/a.py"
-        >>> cfg.item4
-        'test'
-        >>> cfg
-        "Config [path: /home/kchen/projects/mmcv/tests/data/config/a.py]: "
-        "{'item1': [1, 2], 'item2': {'a': 0}, 'item3': True, 'item4': 'test'}"
-    """
-
-    @staticmethod
-    def _validate_py_syntax(filename):
-        with open(filename, 'r', encoding='utf-8') as f:
-            # Setting encoding explicitly to resolve coding issue on windows
-            content = f.read()
-        try:
-            ast.parse(content)
-        except SyntaxError as e:
-            raise SyntaxError('There are syntax errors in config '
-                              f'file {filename}: {e}')
-
-    @staticmethod
-    def _substitute_predefined_vars(filename, temp_config_name):
-        file_dirname = osp.dirname(filename)
-        file_basename = osp.basename(filename)
-        file_basename_no_extension = osp.splitext(file_basename)[0]
-        file_extname = osp.splitext(filename)[1]
-        support_templates = dict(
-            fileDirname=file_dirname,
-            fileBasename=file_basename,
-            fileBasenameNoExtension=file_basename_no_extension,
-            fileExtname=file_extname)
-        with open(filename, 'r', encoding='utf-8') as f:
-            # Setting encoding explicitly to resolve coding issue on windows
-            config_file = f.read()
-        for key, value in support_templates.items():
-            regexp = r'\{\{\s*' + str(key) + r'\s*\}\}'
-            value = value.replace('\\', '/')
-            config_file = re.sub(regexp, value, config_file)
-        with open(temp_config_name, 'w', encoding='utf-8') as tmp_config_file:
-            tmp_config_file.write(config_file)
-
-    @staticmethod
-    def _pre_substitute_base_vars(filename, temp_config_name):
-        """Substitute base variable placehoders to string, so that parsing
-        would work."""
-        with open(filename, 'r', encoding='utf-8') as f:
-            # Setting encoding explicitly to resolve coding issue on windows
-            config_file = f.read()
-        base_var_dict = {}
-        regexp = r'\{\{\s*' + BASE_KEY + r'\.([\w\.]+)\s*\}\}'
-        base_vars = set(re.findall(regexp, config_file))
-        for base_var in base_vars:
-            randstr = f'_{base_var}_{uuid.uuid4().hex.lower()[:6]}'
-            base_var_dict[randstr] = base_var
-            regexp = r'\{\{\s*' + BASE_KEY + r'\.' + base_var + r'\s*\}\}'
-            config_file = re.sub(regexp, f'"{randstr}"', config_file)
-        with open(temp_config_name, 'w', encoding='utf-8') as tmp_config_file:
-            tmp_config_file.write(config_file)
-        return base_var_dict
-
-    @staticmethod
-    def _substitute_base_vars(cfg, base_var_dict, base_cfg):
-        """Substitute variable strings to their actual values."""
-        cfg = copy.deepcopy(cfg)
-
-        if isinstance(cfg, dict):
-            for k, v in cfg.items():
-                if isinstance(v, str) and v in base_var_dict:
-                    new_v = base_cfg
-                    for new_k in base_var_dict[v].split('.'):
-                        new_v = new_v[new_k]
-                    cfg[k] = new_v
-                elif isinstance(v, (list, tuple, dict)):
-                    cfg[k] = Config._substitute_base_vars(
-                        v, base_var_dict, base_cfg)
-        elif isinstance(cfg, tuple):
-            cfg = tuple(
-                Config._substitute_base_vars(c, base_var_dict, base_cfg)
-                for c in cfg)
-        elif isinstance(cfg, list):
-            cfg = [
-                Config._substitute_base_vars(c, base_var_dict, base_cfg)
-                for c in cfg
-            ]
-        elif isinstance(cfg, str) and cfg in base_var_dict:
-            new_v = base_cfg
-            for new_k in base_var_dict[cfg].split('.'):
-                new_v = new_v[new_k]
-            cfg = new_v
-
-        return cfg
-
-    @staticmethod
-    def _file2dict(filename, use_predefined_variables=True):
-        filename = osp.abspath(osp.expanduser(filename))
-        check_file_exist(filename)
-        fileExtname = osp.splitext(filename)[1]
-        if fileExtname not in ['.py', '.json', '.yaml', '.yml']:
-            raise IOError('Only py/yml/yaml/json type are supported now!')
-
-        with tempfile.TemporaryDirectory() as temp_config_dir:
-            temp_config_file = tempfile.NamedTemporaryFile(
-                dir=temp_config_dir, suffix=fileExtname)
-            if platform.system() == 'Windows':
-                temp_config_file.close()
-            temp_config_name = osp.basename(temp_config_file.name)
-            # Substitute predefined variables
-            if use_predefined_variables:
-                Config._substitute_predefined_vars(filename,
-                                                   temp_config_file.name)
-            else:
-                shutil.copyfile(filename, temp_config_file.name)
-            # Substitute base variables from placeholders to strings
-            base_var_dict = Config._pre_substitute_base_vars(
-                temp_config_file.name, temp_config_file.name)
-
-            if filename.endswith('.py'):
-                temp_module_name = osp.splitext(temp_config_name)[0]
-                sys.path.insert(0, temp_config_dir)
-                Config._validate_py_syntax(filename)
-                mod = import_module(temp_module_name)
-                sys.path.pop(0)
-                cfg_dict = {
-                    name: value
-                    for name, value in mod.__dict__.items()
-                    if not name.startswith('__')
-                }
-                # delete imported module
-                del sys.modules[temp_module_name]
-            elif filename.endswith(('.yml', '.yaml', '.json')):
-                import annotator.uniformer.mmcv as mmcv
-                cfg_dict = mmcv.load(temp_config_file.name)
-            # close temp file
-            temp_config_file.close()
-
-        # check deprecation information
-        if DEPRECATION_KEY in cfg_dict:
-            deprecation_info = cfg_dict.pop(DEPRECATION_KEY)
-            warning_msg = f'The config file {filename} will be deprecated ' \
-                'in the future.'
-            if 'expected' in deprecation_info:
-                warning_msg += f' Please use {deprecation_info["expected"]} ' \
-                    'instead.'
-            if 'reference' in deprecation_info:
-                warning_msg += ' More information can be found at ' \
-                    f'{deprecation_info["reference"]}'
-            warnings.warn(warning_msg)
-
-        cfg_text = filename + '\n'
-        with open(filename, 'r', encoding='utf-8') as f:
-            # Setting encoding explicitly to resolve coding issue on windows
-            cfg_text += f.read()
-
-        if BASE_KEY in cfg_dict:
-            cfg_dir = osp.dirname(filename)
-            base_filename = cfg_dict.pop(BASE_KEY)
-            base_filename = base_filename if isinstance(
-                base_filename, list) else [base_filename]
-
-            cfg_dict_list = list()
-            cfg_text_list = list()
-            for f in base_filename:
-                _cfg_dict, _cfg_text = Config._file2dict(osp.join(cfg_dir, f))
-                cfg_dict_list.append(_cfg_dict)
-                cfg_text_list.append(_cfg_text)
-
-            base_cfg_dict = dict()
-            for c in cfg_dict_list:
-                duplicate_keys = base_cfg_dict.keys() & c.keys()
-                if len(duplicate_keys) > 0:
-                    raise KeyError('Duplicate key is not allowed among bases. '
-                                   f'Duplicate keys: {duplicate_keys}')
-                base_cfg_dict.update(c)
-
-            # Substitute base variables from strings to their actual values
-            cfg_dict = Config._substitute_base_vars(cfg_dict, base_var_dict,
-                                                    base_cfg_dict)
-
-            base_cfg_dict = Config._merge_a_into_b(cfg_dict, base_cfg_dict)
-            cfg_dict = base_cfg_dict
-
-            # merge cfg_text
-            cfg_text_list.append(cfg_text)
-            cfg_text = '\n'.join(cfg_text_list)
-
-        return cfg_dict, cfg_text
-
-    @staticmethod
-    def _merge_a_into_b(a, b, allow_list_keys=False):
-        """merge dict ``a`` into dict ``b`` (non-inplace).
-
-        Values in ``a`` will overwrite ``b``. ``b`` is copied first to avoid
-        in-place modifications.
-
-        Args:
-            a (dict): The source dict to be merged into ``b``.
-            b (dict): The origin dict to be fetch keys from ``a``.
-            allow_list_keys (bool): If True, int string keys (e.g. '0', '1')
-              are allowed in source ``a`` and will replace the element of the
-              corresponding index in b if b is a list. Default: False.
-
-        Returns:
-            dict: The modified dict of ``b`` using ``a``.
-
-        Examples:
-            # Normally merge a into b.
-            >>> Config._merge_a_into_b(
-            ...     dict(obj=dict(a=2)), dict(obj=dict(a=1)))
-            {'obj': {'a': 2}}
-
-            # Delete b first and merge a into b.
-            >>> Config._merge_a_into_b(
-            ...     dict(obj=dict(_delete_=True, a=2)), dict(obj=dict(a=1)))
-            {'obj': {'a': 2}}
-
-            # b is a list
-            >>> Config._merge_a_into_b(
-            ...     {'0': dict(a=2)}, [dict(a=1), dict(b=2)], True)
-            [{'a': 2}, {'b': 2}]
-        """
-        b = b.copy()
-        for k, v in a.items():
-            if allow_list_keys and k.isdigit() and isinstance(b, list):
-                k = int(k)
-                if len(b) <= k:
-                    raise KeyError(f'Index {k} exceeds the length of list {b}')
-                b[k] = Config._merge_a_into_b(v, b[k], allow_list_keys)
-            elif isinstance(v,
-                            dict) and k in b and not v.pop(DELETE_KEY, False):
-                allowed_types = (dict, list) if allow_list_keys else dict
-                if not isinstance(b[k], allowed_types):
-                    raise TypeError(
-                        f'{k}={v} in child config cannot inherit from base '
-                        f'because {k} is a dict in the child config but is of '
-                        f'type {type(b[k])} in base config. You may set '
-                        f'`{DELETE_KEY}=True` to ignore the base config')
-                b[k] = Config._merge_a_into_b(v, b[k], allow_list_keys)
-            else:
-                b[k] = v
-        return b
-
-    @staticmethod
-    def fromfile(filename,
-                 use_predefined_variables=True,
-                 import_custom_modules=True):
-        cfg_dict, cfg_text = Config._file2dict(filename,
-                                               use_predefined_variables)
-        if import_custom_modules and cfg_dict.get('custom_imports', None):
-            import_modules_from_strings(**cfg_dict['custom_imports'])
-        return Config(cfg_dict, cfg_text=cfg_text, filename=filename)
-
-    @staticmethod
-    def fromstring(cfg_str, file_format):
-        """Generate config from config str.
-
-        Args:
-            cfg_str (str): Config str.
-            file_format (str): Config file format corresponding to the
-               config str. Only py/yml/yaml/json type are supported now!
-
-        Returns:
-            obj:`Config`: Config obj.
-        """
-        if file_format not in ['.py', '.json', '.yaml', '.yml']:
-            raise IOError('Only py/yml/yaml/json type are supported now!')
-        if file_format != '.py' and 'dict(' in cfg_str:
-            # check if users specify a wrong suffix for python
-            warnings.warn(
-                'Please check "file_format", the file format may be .py')
-        with tempfile.NamedTemporaryFile(
-                'w', encoding='utf-8', suffix=file_format,
-                delete=False) as temp_file:
-            temp_file.write(cfg_str)
-            # on windows, previous implementation cause error
-            # see PR 1077 for details
-        cfg = Config.fromfile(temp_file.name)
-        os.remove(temp_file.name)
-        return cfg
-
-    @staticmethod
-    def auto_argparser(description=None):
-        """Generate argparser from config file automatically (experimental)"""
-        partial_parser = ArgumentParser(description=description)
-        partial_parser.add_argument('config', help='config file path')
-        cfg_file = partial_parser.parse_known_args()[0].config
-        cfg = Config.fromfile(cfg_file)
-        parser = ArgumentParser(description=description)
-        parser.add_argument('config', help='config file path')
-        add_args(parser, cfg)
-        return parser, cfg
-
-    def __init__(self, cfg_dict=None, cfg_text=None, filename=None):
-        if cfg_dict is None:
-            cfg_dict = dict()
-        elif not isinstance(cfg_dict, dict):
-            raise TypeError('cfg_dict must be a dict, but '
-                            f'got {type(cfg_dict)}')
-        for key in cfg_dict:
-            if key in RESERVED_KEYS:
-                raise KeyError(f'{key} is reserved for config file')
-
-        super(Config, self).__setattr__('_cfg_dict', ConfigDict(cfg_dict))
-        super(Config, self).__setattr__('_filename', filename)
-        if cfg_text:
-            text = cfg_text
-        elif filename:
-            with open(filename, 'r') as f:
-                text = f.read()
-        else:
-            text = ''
-        super(Config, self).__setattr__('_text', text)
-
-    @property
-    def filename(self):
-        return self._filename
-
-    @property
-    def text(self):
-        return self._text
-
-    @property
-    def pretty_text(self):
-
-        indent = 4
-
-        def _indent(s_, num_spaces):
-            s = s_.split('\n')
-            if len(s) == 1:
-                return s_
-            first = s.pop(0)
-            s = [(num_spaces * ' ') + line for line in s]
-            s = '\n'.join(s)
-            s = first + '\n' + s
-            return s
-
-        def _format_basic_types(k, v, use_mapping=False):
-            if isinstance(v, str):
-                v_str = f"'{v}'"
-            else:
-                v_str = str(v)
-
-            if use_mapping:
-                k_str = f"'{k}'" if isinstance(k, str) else str(k)
-                attr_str = f'{k_str}: {v_str}'
-            else:
-                attr_str = f'{str(k)}={v_str}'
-            attr_str = _indent(attr_str, indent)
-
-            return attr_str
-
-        def _format_list(k, v, use_mapping=False):
-            # check if all items in the list are dict
-            if all(isinstance(_, dict) for _ in v):
-                v_str = '[\n'
-                v_str += '\n'.join(
-                    f'dict({_indent(_format_dict(v_), indent)}),'
-                    for v_ in v).rstrip(',')
-                if use_mapping:
-                    k_str = f"'{k}'" if isinstance(k, str) else str(k)
-                    attr_str = f'{k_str}: {v_str}'
-                else:
-                    attr_str = f'{str(k)}={v_str}'
-                attr_str = _indent(attr_str, indent) + ']'
-            else:
-                attr_str = _format_basic_types(k, v, use_mapping)
-            return attr_str
-
-        def _contain_invalid_identifier(dict_str):
-            contain_invalid_identifier = False
-            for key_name in dict_str:
-                contain_invalid_identifier |= \
-                    (not str(key_name).isidentifier())
-            return contain_invalid_identifier
-
-        def _format_dict(input_dict, outest_level=False):
-            r = ''
-            s = []
-
-            use_mapping = _contain_invalid_identifier(input_dict)
-            if use_mapping:
-                r += '{'
-            for idx, (k, v) in enumerate(input_dict.items()):
-                is_last = idx >= len(input_dict) - 1
-                end = '' if outest_level or is_last else ','
-                if isinstance(v, dict):
-                    v_str = '\n' + _format_dict(v)
-                    if use_mapping:
-                        k_str = f"'{k}'" if isinstance(k, str) else str(k)
-                        attr_str = f'{k_str}: dict({v_str}'
-                    else:
-                        attr_str = f'{str(k)}=dict({v_str}'
-                    attr_str = _indent(attr_str, indent) + ')' + end
-                elif isinstance(v, list):
-                    attr_str = _format_list(k, v, use_mapping) + end
-                else:
-                    attr_str = _format_basic_types(k, v, use_mapping) + end
-
-                s.append(attr_str)
-            r += '\n'.join(s)
-            if use_mapping:
-                r += '}'
-            return r
-
-        cfg_dict = self._cfg_dict.to_dict()
-        text = _format_dict(cfg_dict, outest_level=True)
-        # copied from setup.cfg
-        yapf_style = dict(
-            based_on_style='pep8',
-            blank_line_before_nested_class_or_def=True,
-            split_before_expression_after_opening_paren=True)
-        text, _ = FormatCode(text, style_config=yapf_style, verify=True)
-
-        return text
-
-    def __repr__(self):
-        return f'Config (path: {self.filename}): {self._cfg_dict.__repr__()}'
-
-    def __len__(self):
-        return len(self._cfg_dict)
-
-    def __getattr__(self, name):
-        return getattr(self._cfg_dict, name)
-
-    def __getitem__(self, name):
-        return self._cfg_dict.__getitem__(name)
-
-    def __setattr__(self, name, value):
-        if isinstance(value, dict):
-            value = ConfigDict(value)
-        self._cfg_dict.__setattr__(name, value)
-
-    def __setitem__(self, name, value):
-        if isinstance(value, dict):
-            value = ConfigDict(value)
-        self._cfg_dict.__setitem__(name, value)
-
-    def __iter__(self):
-        return iter(self._cfg_dict)
-
-    def __getstate__(self):
-        return (self._cfg_dict, self._filename, self._text)
-
-    def __setstate__(self, state):
-        _cfg_dict, _filename, _text = state
-        super(Config, self).__setattr__('_cfg_dict', _cfg_dict)
-        super(Config, self).__setattr__('_filename', _filename)
-        super(Config, self).__setattr__('_text', _text)
-
-    def dump(self, file=None):
-        cfg_dict = super(Config, self).__getattribute__('_cfg_dict').to_dict()
-        if self.filename.endswith('.py'):
-            if file is None:
-                return self.pretty_text
-            else:
-                with open(file, 'w', encoding='utf-8') as f:
-                    f.write(self.pretty_text)
-        else:
-            import annotator.uniformer.mmcv as mmcv
-            if file is None:
-                file_format = self.filename.split('.')[-1]
-                return mmcv.dump(cfg_dict, file_format=file_format)
-            else:
-                mmcv.dump(cfg_dict, file)
-
-    def merge_from_dict(self, options, allow_list_keys=True):
-        """Merge list into cfg_dict.
-
-        Merge the dict parsed by MultipleKVAction into this cfg.
-
-        Examples:
-            >>> options = {'model.backbone.depth': 50,
-            ...            'model.backbone.with_cp':True}
-            >>> cfg = Config(dict(model=dict(backbone=dict(type='ResNet'))))
-            >>> cfg.merge_from_dict(options)
-            >>> cfg_dict = super(Config, self).__getattribute__('_cfg_dict')
-            >>> assert cfg_dict == dict(
-            ...     model=dict(backbone=dict(depth=50, with_cp=True)))
-
-            # Merge list element
-            >>> cfg = Config(dict(pipeline=[
-            ...     dict(type='LoadImage'), dict(type='LoadAnnotations')]))
-            >>> options = dict(pipeline={'0': dict(type='SelfLoadImage')})
-            >>> cfg.merge_from_dict(options, allow_list_keys=True)
-            >>> cfg_dict = super(Config, self).__getattribute__('_cfg_dict')
-            >>> assert cfg_dict == dict(pipeline=[
-            ...     dict(type='SelfLoadImage'), dict(type='LoadAnnotations')])
-
-        Args:
-            options (dict): dict of configs to merge from.
-            allow_list_keys (bool): If True, int string keys (e.g. '0', '1')
-              are allowed in ``options`` and will replace the element of the
-              corresponding index in the config if the config is a list.
-              Default: True.
-        """
-        option_cfg_dict = {}
-        for full_key, v in options.items():
-            d = option_cfg_dict
-            key_list = full_key.split('.')
-            for subkey in key_list[:-1]:
-                d.setdefault(subkey, ConfigDict())
-                d = d[subkey]
-            subkey = key_list[-1]
-            d[subkey] = v
-
-        cfg_dict = super(Config, self).__getattribute__('_cfg_dict')
-        super(Config, self).__setattr__(
-            '_cfg_dict',
-            Config._merge_a_into_b(
-                option_cfg_dict, cfg_dict, allow_list_keys=allow_list_keys))
-
-
-class DictAction(Action):
-    """
-    argparse action to split an argument into KEY=VALUE form
-    on the first = and append to a dictionary. List options can
-    be passed as comma separated values, i.e 'KEY=V1,V2,V3', or with explicit
-    brackets, i.e. 'KEY=[V1,V2,V3]'. It also support nested brackets to build
-    list/tuple values. e.g. 'KEY=[(V1,V2),(V3,V4)]'
-    """
-
-    @staticmethod
-    def _parse_int_float_bool(val):
-        try:
-            return int(val)
-        except ValueError:
-            pass
-        try:
-            return float(val)
-        except ValueError:
-            pass
-        if val.lower() in ['true', 'false']:
-            return True if val.lower() == 'true' else False
-        return val
-
-    @staticmethod
-    def _parse_iterable(val):
-        """Parse iterable values in the string.
-
-        All elements inside '()' or '[]' are treated as iterable values.
-
-        Args:
-            val (str): Value string.
-
-        Returns:
-            list | tuple: The expanded list or tuple from the string.
-
-        Examples:
-            >>> DictAction._parse_iterable('1,2,3')
-            [1, 2, 3]
-            >>> DictAction._parse_iterable('[a, b, c]')
-            ['a', 'b', 'c']
-            >>> DictAction._parse_iterable('[(1, 2, 3), [a, b], c]')
-            [(1, 2, 3), ['a', 'b'], 'c']
-        """
-
-        def find_next_comma(string):
-            """Find the position of next comma in the string.
-
-            If no ',' is found in the string, return the string length. All
-            chars inside '()' and '[]' are treated as one element and thus ','
-            inside these brackets are ignored.
-            """
-            assert (string.count('(') == string.count(')')) and (
-                    string.count('[') == string.count(']')), \
-                f'Imbalanced brackets exist in {string}'
-            end = len(string)
-            for idx, char in enumerate(string):
-                pre = string[:idx]
-                # The string before this ',' is balanced
-                if ((char == ',') and (pre.count('(') == pre.count(')'))
-                        and (pre.count('[') == pre.count(']'))):
-                    end = idx
-                    break
-            return end
-
-        # Strip ' and " characters and replace whitespace.
-        val = val.strip('\'\"').replace(' ', '')
-        is_tuple = False
-        if val.startswith('(') and val.endswith(')'):
-            is_tuple = True
-            val = val[1:-1]
-        elif val.startswith('[') and val.endswith(']'):
-            val = val[1:-1]
-        elif ',' not in val:
-            # val is a single value
-            return DictAction._parse_int_float_bool(val)
-
-        values = []
-        while len(val) > 0:
-            comma_idx = find_next_comma(val)
-            element = DictAction._parse_iterable(val[:comma_idx])
-            values.append(element)
-            val = val[comma_idx + 1:]
-        if is_tuple:
-            values = tuple(values)
-        return values
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        options = {}
-        for kv in values:
-            key, val = kv.split('=', maxsplit=1)
-            options[key] = self._parse_iterable(val)
-        setattr(namespace, self.dest, options)
diff --git a/spaces/Pinwheel/GLIP-BLIP-Object-Detection-VQA/models/xbert.py b/spaces/Pinwheel/GLIP-BLIP-Object-Detection-VQA/models/xbert.py
deleted file mode 100644
index 5b1f7774524bacc0c91a15ec66a8063de3f332a2..0000000000000000000000000000000000000000
--- a/spaces/Pinwheel/GLIP-BLIP-Object-Detection-VQA/models/xbert.py
+++ /dev/null
@@ -1,1916 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
-# Copyright (c) 2018, 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.
-"""PyTorch BERT model. """
-
-import math
-import os
-import warnings
-from dataclasses import dataclass
-from typing import Optional, Tuple
-
-import torch
-from torch import Tensor, device, dtype, nn
-import torch.utils.checkpoint
-from torch import nn
-from torch.nn import CrossEntropyLoss, MSELoss
-import torch.nn.functional as F
-
-from transformers.activations import ACT2FN
-from transformers.file_utils import (
-    ModelOutput,
-    add_code_sample_docstrings,
-    add_start_docstrings,
-    add_start_docstrings_to_model_forward,
-    replace_return_docstrings,
-)
-from transformers.modeling_outputs import (
-    BaseModelOutputWithPastAndCrossAttentions,
-    BaseModelOutputWithPoolingAndCrossAttentions,
-    CausalLMOutputWithCrossAttentions,
-    MaskedLMOutput,
-    MultipleChoiceModelOutput,
-    NextSentencePredictorOutput,
-    QuestionAnsweringModelOutput,
-    SequenceClassifierOutput,
-    TokenClassifierOutput,
-)
-from transformers.modeling_utils import (
-    PreTrainedModel,
-    apply_chunking_to_forward,
-    find_pruneable_heads_and_indices,
-    prune_linear_layer,
-)
-from transformers.utils import logging
-from transformers.models.bert.configuration_bert import BertConfig
-
-import transformers
-transformers.logging.set_verbosity_error()
-
-logger = logging.get_logger(__name__)
-
-_CONFIG_FOR_DOC = "BertConfig"
-_TOKENIZER_FOR_DOC = "BertTokenizer"
-
-BERT_PRETRAINED_MODEL_ARCHIVE_LIST = [
-    "bert-base-uncased",
-    "bert-large-uncased",
-    "bert-base-cased",
-    "bert-large-cased",
-    "bert-base-multilingual-uncased",
-    "bert-base-multilingual-cased",
-    "bert-base-chinese",
-    "bert-base-german-cased",
-    "bert-large-uncased-whole-word-masking",
-    "bert-large-cased-whole-word-masking",
-    "bert-large-uncased-whole-word-masking-finetuned-squad",
-    "bert-large-cased-whole-word-masking-finetuned-squad",
-    "bert-base-cased-finetuned-mrpc",
-    "bert-base-german-dbmdz-cased",
-    "bert-base-german-dbmdz-uncased",
-    "cl-tohoku/bert-base-japanese",
-    "cl-tohoku/bert-base-japanese-whole-word-masking",
-    "cl-tohoku/bert-base-japanese-char",
-    "cl-tohoku/bert-base-japanese-char-whole-word-masking",
-    "TurkuNLP/bert-base-finnish-cased-v1",
-    "TurkuNLP/bert-base-finnish-uncased-v1",
-    "wietsedv/bert-base-dutch-cased",
-    # See all BERT models at https://huggingface.co/models?filter=bert
-]
-
-
-def load_tf_weights_in_bert(model, config, tf_checkpoint_path):
-    """Load tf checkpoints in a pytorch model."""
-    try:
-        import re
-
-        import numpy as np
-        import tensorflow as tf
-    except ImportError:
-        logger.error(
-            "Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see "
-            "https://www.tensorflow.org/install/ for installation instructions."
-        )
-        raise
-    tf_path = os.path.abspath(tf_checkpoint_path)
-    logger.info("Converting TensorFlow checkpoint from {}".format(tf_path))
-    # Load weights from TF model
-    init_vars = tf.train.list_variables(tf_path)
-    names = []
-    arrays = []
-    for name, shape in init_vars:
-        logger.info("Loading TF weight {} with shape {}".format(name, shape))
-        array = tf.train.load_variable(tf_path, name)
-        names.append(name)
-        arrays.append(array)
-
-    for name, array in zip(names, arrays):
-        name = name.split("/")
-        # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v
-        # which are not required for using pretrained model
-        if any(
-            n in ["adam_v", "adam_m", "AdamWeightDecayOptimizer", "AdamWeightDecayOptimizer_1", "global_step"]
-            for n in name
-        ):
-            logger.info("Skipping {}".format("/".join(name)))
-            continue
-        pointer = model
-        for m_name in name:
-            if re.fullmatch(r"[A-Za-z]+_\d+", m_name):
-                scope_names = re.split(r"_(\d+)", m_name)
-            else:
-                scope_names = [m_name]
-            if scope_names[0] == "kernel" or scope_names[0] == "gamma":
-                pointer = getattr(pointer, "weight")
-            elif scope_names[0] == "output_bias" or scope_names[0] == "beta":
-                pointer = getattr(pointer, "bias")
-            elif scope_names[0] == "output_weights":
-                pointer = getattr(pointer, "weight")
-            elif scope_names[0] == "squad":
-                pointer = getattr(pointer, "classifier")
-            else:
-                try:
-                    pointer = getattr(pointer, scope_names[0])
-                except AttributeError:
-                    logger.info("Skipping {}".format("/".join(name)))
-                    continue
-            if len(scope_names) >= 2:
-                num = int(scope_names[1])
-                pointer = pointer[num]
-        if m_name[-11:] == "_embeddings":
-            pointer = getattr(pointer, "weight")
-        elif m_name == "kernel":
-            array = np.transpose(array)
-        try:
-            assert (
-                pointer.shape == array.shape
-            ), f"Pointer shape {pointer.shape} and array shape {array.shape} mismatched"
-        except AssertionError as e:
-            e.args += (pointer.shape, array.shape)
-            raise
-        logger.info("Initialize PyTorch weight {}".format(name))
-        pointer.data = torch.from_numpy(array)
-    return model
-
-
-class BertEmbeddings(nn.Module):
-    """Construct the embeddings from word, position and token_type embeddings."""
-
-    def __init__(self, config):
-        super().__init__()
-        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
-        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
-        self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)
-
-        # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
-        # any TensorFlow checkpoint file
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
-        # position_ids (1, len position emb) is contiguous in memory and exported when serialized
-        self.register_buffer("position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)))
-        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
-        
-        self.config = config
-
-    def forward(
-        self, input_ids=None, token_type_ids=None, position_ids=None, inputs_embeds=None, past_key_values_length=0
-    ):
-        if input_ids is not None:
-            input_shape = input_ids.size()
-        else:
-            input_shape = inputs_embeds.size()[:-1]
-
-        seq_length = input_shape[1]
-
-        if position_ids is None:
-            position_ids = self.position_ids[:, past_key_values_length : seq_length + past_key_values_length]
-
-        if token_type_ids is None:
-            token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=self.position_ids.device)
-
-        if inputs_embeds is None:
-            inputs_embeds = self.word_embeddings(input_ids)
-        
-        token_type_embeddings = self.token_type_embeddings(token_type_ids)  
-
-        embeddings = inputs_embeds + token_type_embeddings
-        if self.position_embedding_type == "absolute":
-            position_embeddings = self.position_embeddings(position_ids)
-            embeddings += position_embeddings
-        embeddings = self.LayerNorm(embeddings)
-        embeddings = self.dropout(embeddings)
-        return embeddings
-
-
-class BertSelfAttention(nn.Module):
-    def __init__(self, config, is_cross_attention):
-        super().__init__()
-        self.config = config
-        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
-            raise ValueError(
-                "The hidden size (%d) is not a multiple of the number of attention "
-                "heads (%d)" % (config.hidden_size, config.num_attention_heads)
-            )
-        
-        self.num_attention_heads = config.num_attention_heads
-        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
-        self.all_head_size = self.num_attention_heads * self.attention_head_size
-
-        self.query = nn.Linear(config.hidden_size, self.all_head_size)
-        if is_cross_attention:
-            self.key = nn.Linear(config.encoder_width, self.all_head_size)
-            self.value = nn.Linear(config.encoder_width, self.all_head_size)
-        else:
-            self.key = nn.Linear(config.hidden_size, self.all_head_size)
-            self.value = nn.Linear(config.hidden_size, self.all_head_size)
-
-        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
-        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
-        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
-            self.max_position_embeddings = config.max_position_embeddings
-            self.distance_embedding = nn.Embedding(2 * config.max_position_embeddings - 1, self.attention_head_size)
-        self.save_attention = False   
-            
-    def save_attn_gradients(self, attn_gradients):
-        self.attn_gradients = attn_gradients
-        
-    def get_attn_gradients(self):
-        return self.attn_gradients
-    
-    def save_attention_map(self, attention_map):
-        self.attention_map = attention_map
-        
-    def get_attention_map(self):
-        return self.attention_map
-    
-
-    def transpose_for_scores(self, x):
-        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
-        x = x.view(*new_x_shape)
-        return x.permute(0, 2, 1, 3)
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_value=None,
-        output_attentions=False,
-    ):
-        mixed_query_layer = self.query(hidden_states)
-
-        # If this is instantiated as a cross-attention module, the keys
-        # and values come from an encoder; the attention mask needs to be
-        # such that the encoder's padding tokens are not attended to.
-        is_cross_attention = encoder_hidden_states is not None
-
-
-        if is_cross_attention:
-            key_layer = self.transpose_for_scores(self.key(encoder_hidden_states))
-            value_layer = self.transpose_for_scores(self.value(encoder_hidden_states))
-            attention_mask = encoder_attention_mask
-        elif past_key_value is not None:
-            key_layer = self.transpose_for_scores(self.key(hidden_states))
-            value_layer = self.transpose_for_scores(self.value(hidden_states))
-            key_layer = torch.cat([past_key_value[0], key_layer], dim=2)
-            value_layer = torch.cat([past_key_value[1], value_layer], dim=2)
-        else:
-            key_layer = self.transpose_for_scores(self.key(hidden_states))
-            value_layer = self.transpose_for_scores(self.value(hidden_states))
-
-        query_layer = self.transpose_for_scores(mixed_query_layer)
-
-        past_key_value = (key_layer, value_layer)
-
-        # Take the dot product between "query" and "key" to get the raw attention scores.
-        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
-
-        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
-            seq_length = hidden_states.size()[1]
-            position_ids_l = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(-1, 1)
-            position_ids_r = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(1, -1)
-            distance = position_ids_l - position_ids_r
-            positional_embedding = self.distance_embedding(distance + self.max_position_embeddings - 1)
-            positional_embedding = positional_embedding.to(dtype=query_layer.dtype)  # fp16 compatibility
-
-            if self.position_embedding_type == "relative_key":
-                relative_position_scores = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
-                attention_scores = attention_scores + relative_position_scores
-            elif self.position_embedding_type == "relative_key_query":
-                relative_position_scores_query = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
-                relative_position_scores_key = torch.einsum("bhrd,lrd->bhlr", key_layer, positional_embedding)
-                attention_scores = attention_scores + relative_position_scores_query + relative_position_scores_key
-
-        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
-        if attention_mask is not None:
-            # Apply the attention mask is (precomputed for all layers in BertModel forward() function)
-            attention_scores = attention_scores + attention_mask
-
-        # Normalize the attention scores to probabilities.
-        attention_probs = nn.Softmax(dim=-1)(attention_scores)
-        
-        if is_cross_attention and self.save_attention:
-            self.save_attention_map(attention_probs)
-            attention_probs.register_hook(self.save_attn_gradients)         
-
-        # This is actually dropping out entire tokens to attend to, which might
-        # seem a bit unusual, but is taken from the original Transformer paper.
-        attention_probs_dropped = self.dropout(attention_probs)
-
-        # Mask heads if we want to
-        if head_mask is not None:
-            attention_probs_dropped = attention_probs_dropped * head_mask
-
-        context_layer = torch.matmul(attention_probs_dropped, value_layer)
-
-        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
-        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
-        context_layer = context_layer.view(*new_context_layer_shape)
-
-        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
-
-        outputs = outputs + (past_key_value,)
-        return outputs
-
-
-class BertSelfOutput(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
-    def forward(self, hidden_states, input_tensor):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.dropout(hidden_states)
-        hidden_states = self.LayerNorm(hidden_states + input_tensor)
-        return hidden_states
-
-
-class BertAttention(nn.Module):
-    def __init__(self, config, is_cross_attention=False):
-        super().__init__()
-        self.self = BertSelfAttention(config, is_cross_attention)
-        self.output = BertSelfOutput(config)
-        self.pruned_heads = set()
-
-    def prune_heads(self, heads):
-        if len(heads) == 0:
-            return
-        heads, index = find_pruneable_heads_and_indices(
-            heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
-        )
-
-        # Prune linear layers
-        self.self.query = prune_linear_layer(self.self.query, index)
-        self.self.key = prune_linear_layer(self.self.key, index)
-        self.self.value = prune_linear_layer(self.self.value, index)
-        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
-
-        # Update hyper params and store pruned heads
-        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
-        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
-        self.pruned_heads = self.pruned_heads.union(heads)
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_value=None,
-        output_attentions=False,
-    ):
-        self_outputs = self.self(
-            hidden_states,
-            attention_mask,
-            head_mask,
-            encoder_hidden_states,
-            encoder_attention_mask,
-            past_key_value,
-            output_attentions,
-        )
-        attention_output = self.output(self_outputs[0], hidden_states)
-        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
-        return outputs
-
-
-class BertIntermediate(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
-        if isinstance(config.hidden_act, str):
-            self.intermediate_act_fn = ACT2FN[config.hidden_act]
-        else:
-            self.intermediate_act_fn = config.hidden_act
-
-    def forward(self, hidden_states):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.intermediate_act_fn(hidden_states)
-        return hidden_states
-
-
-class BertOutput(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
-    def forward(self, hidden_states, input_tensor):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.dropout(hidden_states)
-        hidden_states = self.LayerNorm(hidden_states + input_tensor)
-        return hidden_states
-
-
-class BertLayer(nn.Module):
-    def __init__(self, config, layer_num):
-        super().__init__()
-        self.config = config
-        self.chunk_size_feed_forward = config.chunk_size_feed_forward
-        self.seq_len_dim = 1
-        self.attention = BertAttention(config)
-
-        self.has_cross_attention = (layer_num >= config.fusion_layer)
-        if self.has_cross_attention:           
-            self.layer_num = layer_num                
-            self.crossattention = BertAttention(config, is_cross_attention=True)
-        self.intermediate = BertIntermediate(config)
-        self.output = BertOutput(config)
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_value=None,
-        output_attentions=False,
-    ):
-        # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
-        self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None
-        self_attention_outputs = self.attention(
-            hidden_states,
-            attention_mask,
-            head_mask,
-            output_attentions=output_attentions,
-            past_key_value=self_attn_past_key_value,
-        )
-        attention_output = self_attention_outputs[0]
-
-        outputs = self_attention_outputs[1:-1]
-        present_key_value = self_attention_outputs[-1]
-
-        if self.has_cross_attention:
-            assert encoder_hidden_states is not None, "encoder_hidden_states must be given for cross-attention layers"
-            
-            if type(encoder_hidden_states) == list:
-                cross_attention_outputs = self.crossattention(
-                    attention_output,
-                    attention_mask,
-                    head_mask,
-                    encoder_hidden_states[(self.layer_num-self.config.fusion_layer)%len(encoder_hidden_states)],
-                    encoder_attention_mask[(self.layer_num-self.config.fusion_layer)%len(encoder_hidden_states)],
-                    output_attentions=output_attentions,
-                )    
-                attention_output = cross_attention_outputs[0]
-                outputs = outputs + cross_attention_outputs[1:-1]
-         
-            else:
-                cross_attention_outputs = self.crossattention(
-                    attention_output,
-                    attention_mask,
-                    head_mask,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                    output_attentions=output_attentions,
-                )
-                attention_output = cross_attention_outputs[0]
-                outputs = outputs + cross_attention_outputs[1:-1]  # add cross attentions if we output attention weights                               
-        layer_output = apply_chunking_to_forward(
-            self.feed_forward_chunk, self.chunk_size_feed_forward, self.seq_len_dim, attention_output
-        )
-        outputs = (layer_output,) + outputs
-
-        outputs = outputs + (present_key_value,)
-
-        return outputs
-
-    def feed_forward_chunk(self, attention_output):
-        intermediate_output = self.intermediate(attention_output)
-        layer_output = self.output(intermediate_output, attention_output)
-        return layer_output
-
-
-class BertEncoder(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.config = config
-        self.layer = nn.ModuleList([BertLayer(config,i) for i in range(config.num_hidden_layers)])
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_values=None,
-        use_cache=None,
-        output_attentions=False,
-        output_hidden_states=False,
-        return_dict=True,
-        mode='multi_modal',
-    ):
-        all_hidden_states = () if output_hidden_states else None
-        all_self_attentions = () if output_attentions else None
-        all_cross_attentions = () if output_attentions and self.config.add_cross_attention else None
-
-        next_decoder_cache = () if use_cache else None
-        
-                
-        if mode=='text': 
-            start_layer = 0
-            output_layer = self.config.fusion_layer
-            
-        elif mode=='fusion':
-            start_layer = self.config.fusion_layer
-            output_layer = self.config.num_hidden_layers
-            
-        elif mode=='multi_modal':
-            start_layer = 0
-            output_layer = self.config.num_hidden_layers        
-        
-        for i in range(start_layer, output_layer):
-            layer_module = self.layer[i]
-            if output_hidden_states:
-                all_hidden_states = all_hidden_states + (hidden_states,)
-
-            layer_head_mask = head_mask[i] if head_mask is not None else None
-            past_key_value = past_key_values[i] if past_key_values is not None else None
-
-            if getattr(self.config, "gradient_checkpointing", False) and self.training:
-
-                if use_cache:
-                    logger.warn(
-                        "`use_cache=True` is incompatible with `config.gradient_checkpointing=True`. Setting "
-                        "`use_cache=False`..."
-                    )
-                    use_cache = False
-
-                def create_custom_forward(module):
-                    def custom_forward(*inputs):
-                        return module(*inputs, past_key_value, output_attentions)
-
-                    return custom_forward
-
-                layer_outputs = torch.utils.checkpoint.checkpoint(
-                    create_custom_forward(layer_module),
-                    hidden_states,
-                    attention_mask,
-                    layer_head_mask,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                )
-            else:
-                layer_outputs = layer_module(
-                    hidden_states,
-                    attention_mask,
-                    layer_head_mask,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                    past_key_value,
-                    output_attentions,
-                )
-
-            hidden_states = layer_outputs[0]
-            if use_cache:
-                next_decoder_cache += (layer_outputs[-1],)
-            if output_attentions:
-                all_self_attentions = all_self_attentions + (layer_outputs[1],)
-
-        if output_hidden_states:
-            all_hidden_states = all_hidden_states + (hidden_states,)
-
-        if not return_dict:
-            return tuple(
-                v
-                for v in [
-                    hidden_states,
-                    next_decoder_cache,
-                    all_hidden_states,
-                    all_self_attentions,
-                    all_cross_attentions,
-                ]
-                if v is not None
-            )
-        return BaseModelOutputWithPastAndCrossAttentions(
-            last_hidden_state=hidden_states,
-            past_key_values=next_decoder_cache,
-            hidden_states=all_hidden_states,
-            attentions=all_self_attentions,
-            cross_attentions=all_cross_attentions,
-        )
-
-
-class BertPooler(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        self.activation = nn.Tanh()
-
-    def forward(self, hidden_states):
-        # We "pool" the model by simply taking the hidden state corresponding
-        # to the first token.
-        first_token_tensor = hidden_states[:, 0]
-        pooled_output = self.dense(first_token_tensor)
-        pooled_output = self.activation(pooled_output)
-        return pooled_output
-
-
-class BertPredictionHeadTransform(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        if isinstance(config.hidden_act, str):
-            self.transform_act_fn = ACT2FN[config.hidden_act]
-        else:
-            self.transform_act_fn = config.hidden_act
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-
-    def forward(self, hidden_states):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.transform_act_fn(hidden_states)
-        hidden_states = self.LayerNorm(hidden_states)
-        return hidden_states
-
-
-class BertLMPredictionHead(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.transform = BertPredictionHeadTransform(config)
-
-        # The output weights are the same as the input embeddings, but there is
-        # an output-only bias for each token.
-        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
-
-        self.bias = nn.Parameter(torch.zeros(config.vocab_size))
-
-        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
-        self.decoder.bias = self.bias
-
-    def forward(self, hidden_states):
-        hidden_states = self.transform(hidden_states)
-        hidden_states = self.decoder(hidden_states)
-        return hidden_states
-
-
-class BertOnlyMLMHead(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.predictions = BertLMPredictionHead(config)
-
-    def forward(self, sequence_output):
-        prediction_scores = self.predictions(sequence_output)
-        return prediction_scores
-
-
-class BertOnlyNSPHead(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.seq_relationship = nn.Linear(config.hidden_size, 2)
-
-    def forward(self, pooled_output):
-        seq_relationship_score = self.seq_relationship(pooled_output)
-        return seq_relationship_score
-
-
-class BertPreTrainingHeads(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.predictions = BertLMPredictionHead(config)
-        self.seq_relationship = nn.Linear(config.hidden_size, 2)
-
-    def forward(self, sequence_output, pooled_output):
-        prediction_scores = self.predictions(sequence_output)
-        seq_relationship_score = self.seq_relationship(pooled_output)
-        return prediction_scores, seq_relationship_score
-
-
-class BertPreTrainedModel(PreTrainedModel):
-    """
-    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
-    models.
-    """
-
-    config_class = BertConfig
-    load_tf_weights = load_tf_weights_in_bert
-    base_model_prefix = "bert"
-    _keys_to_ignore_on_load_missing = [r"position_ids"]
-
-    def _init_weights(self, module):
-        """ Initialize the weights """
-        if isinstance(module, (nn.Linear, nn.Embedding)):
-            # Slightly different from the TF version which uses truncated_normal for initialization
-            # cf https://github.com/pytorch/pytorch/pull/5617
-            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
-        elif isinstance(module, nn.LayerNorm):
-            module.bias.data.zero_()
-            module.weight.data.fill_(1.0)
-        if isinstance(module, nn.Linear) and module.bias is not None:
-            module.bias.data.zero_()
-
-
-@dataclass
-class BertForPreTrainingOutput(ModelOutput):
-    """
-    Output type of :class:`~transformers.BertForPreTraining`.
-    Args:
-        loss (`optional`, returned when ``labels`` is provided, ``torch.FloatTensor`` of shape :obj:`(1,)`):
-            Total loss as the sum of the masked language modeling loss and the next sequence prediction
-            (classification) loss.
-        prediction_logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, config.vocab_size)`):
-            Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
-        seq_relationship_logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, 2)`):
-            Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation
-            before SoftMax).
-        hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``):
-            Tuple of :obj:`torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer)
-            of shape :obj:`(batch_size, sequence_length, hidden_size)`.
-            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
-        attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``):
-            Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape :obj:`(batch_size, num_heads,
-            sequence_length, sequence_length)`.
-            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
-            heads.
-    """
-
-    loss: Optional[torch.FloatTensor] = None
-    prediction_logits: torch.FloatTensor = None
-    seq_relationship_logits: torch.FloatTensor = None
-    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
-    attentions: Optional[Tuple[torch.FloatTensor]] = None
-
-
-BERT_START_DOCSTRING = r"""
-    This model inherits from :class:`~transformers.PreTrainedModel`. Check the superclass documentation for the generic
-    methods the library implements for all its model (such as downloading or saving, resizing the input embeddings,
-    pruning heads etc.)
-    This model is also a PyTorch `torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>`__
-    subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to
-    general usage and behavior.
-    Parameters:
-        config (:class:`~transformers.BertConfig`): Model configuration class with all the parameters of the model.
-            Initializing with a config file does not load the weights associated with the model, only the
-            configuration. Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model
-            weights.
-"""
-
-BERT_INPUTS_DOCSTRING = r"""
-    Args:
-        input_ids (:obj:`torch.LongTensor` of shape :obj:`({0})`):
-            Indices of input sequence tokens in the vocabulary.
-            Indices can be obtained using :class:`~transformers.BertTokenizer`. See
-            :meth:`transformers.PreTrainedTokenizer.encode` and :meth:`transformers.PreTrainedTokenizer.__call__` for
-            details.
-            `What are input IDs? <../glossary.html#input-ids>`__
-        attention_mask (:obj:`torch.FloatTensor` of shape :obj:`({0})`, `optional`):
-            Mask to avoid performing attention on padding token indices. Mask values selected in ``[0, 1]``:
-            - 1 for tokens that are **not masked**,
-            - 0 for tokens that are **masked**.
-            `What are attention masks? <../glossary.html#attention-mask>`__
-        token_type_ids (:obj:`torch.LongTensor` of shape :obj:`({0})`, `optional`):
-            Segment token indices to indicate first and second portions of the inputs. Indices are selected in ``[0,
-            1]``:
-            - 0 corresponds to a `sentence A` token,
-            - 1 corresponds to a `sentence B` token.
-            `What are token type IDs? <../glossary.html#token-type-ids>`_
-        position_ids (:obj:`torch.LongTensor` of shape :obj:`({0})`, `optional`):
-            Indices of positions of each input sequence tokens in the position embeddings. Selected in the range ``[0,
-            config.max_position_embeddings - 1]``.
-            `What are position IDs? <../glossary.html#position-ids>`_
-        head_mask (:obj:`torch.FloatTensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`):
-            Mask to nullify selected heads of the self-attention modules. Mask values selected in ``[0, 1]``:
-            - 1 indicates the head is **not masked**,
-            - 0 indicates the head is **masked**.
-        inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`({0}, hidden_size)`, `optional`):
-            Optionally, instead of passing :obj:`input_ids` you can choose to directly pass an embedded representation.
-            This is useful if you want more control over how to convert :obj:`input_ids` indices into associated
-            vectors than the model's internal embedding lookup matrix.
-        output_attentions (:obj:`bool`, `optional`):
-            Whether or not to return the attentions tensors of all attention layers. See ``attentions`` under returned
-            tensors for more detail.
-        output_hidden_states (:obj:`bool`, `optional`):
-            Whether or not to return the hidden states of all layers. See ``hidden_states`` under returned tensors for
-            more detail.
-        return_dict (:obj:`bool`, `optional`):
-            Whether or not to return a :class:`~transformers.file_utils.ModelOutput` instead of a plain tuple.
-"""
-
-
-@add_start_docstrings(
-    "The bare Bert Model transformer outputting raw hidden-states without any specific head on top.",
-    BERT_START_DOCSTRING,
-)
-class BertModel(BertPreTrainedModel):
-    """
-    The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of
-    cross-attention is added between the self-attention layers, following the architecture described in `Attention is
-    all you need <https://arxiv.org/abs/1706.03762>`__ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit,
-    Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
-    argument and :obj:`add_cross_attention` set to :obj:`True`; an :obj:`encoder_hidden_states` is then expected as an
-    input to the forward pass.
-    """
-
-    def __init__(self, config, add_pooling_layer=True):
-        super().__init__(config)
-        self.config = config
-
-        self.embeddings = BertEmbeddings(config)
-        
-        self.encoder = BertEncoder(config)
-
-        self.pooler = BertPooler(config) if add_pooling_layer else None
-
-        self.init_weights()
- 
-
-    def get_input_embeddings(self):
-        return self.embeddings.word_embeddings
-
-    def set_input_embeddings(self, value):
-        self.embeddings.word_embeddings = value
-
-    def _prune_heads(self, heads_to_prune):
-        """
-        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
-        class PreTrainedModel
-        """
-        for layer, heads in heads_to_prune.items():
-            self.encoder.layer[layer].attention.prune_heads(heads)
-
-    @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
-    @add_code_sample_docstrings(
-        tokenizer_class=_TOKENIZER_FOR_DOC,
-        checkpoint="bert-base-uncased",
-        output_type=BaseModelOutputWithPoolingAndCrossAttentions,
-        config_class=_CONFIG_FOR_DOC,
-    )
-    
-    
-    def get_extended_attention_mask(self, attention_mask: Tensor, input_shape: Tuple[int], device: device, is_decoder: bool) -> Tensor:
-        """
-        Makes broadcastable attention and causal masks so that future and masked tokens are ignored.
-
-        Arguments:
-            attention_mask (:obj:`torch.Tensor`):
-                Mask with ones indicating tokens to attend to, zeros for tokens to ignore.
-            input_shape (:obj:`Tuple[int]`):
-                The shape of the input to the model.
-            device: (:obj:`torch.device`):
-                The device of the input to the model.
-
-        Returns:
-            :obj:`torch.Tensor` The extended attention mask, with a the same dtype as :obj:`attention_mask.dtype`.
-        """
-        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
-        # ourselves in which case we just need to make it broadcastable to all heads.
-        if attention_mask.dim() == 3:
-            extended_attention_mask = attention_mask[:, None, :, :]
-        elif attention_mask.dim() == 2:
-            # Provided a padding mask of dimensions [batch_size, seq_length]
-            # - if the model is a decoder, apply a causal mask in addition to the padding mask
-            # - if the model is an encoder, make the mask broadcastable to [batch_size, num_heads, seq_length, seq_length]
-            if is_decoder:
-                batch_size, seq_length = input_shape
-                seq_ids = torch.arange(seq_length, device=device)
-                causal_mask = seq_ids[None, None, :].repeat(batch_size, seq_length, 1) <= seq_ids[None, :, None]
-                # in case past_key_values are used we need to add a prefix ones mask to the causal mask
-                # causal and attention masks must have same type with pytorch version < 1.3
-                causal_mask = causal_mask.to(attention_mask.dtype)
-
-                if causal_mask.shape[1] < attention_mask.shape[1]:
-                    prefix_seq_len = attention_mask.shape[1] - causal_mask.shape[1]
-                    causal_mask = torch.cat(
-                        [
-                            torch.ones(
-                                (batch_size, seq_length, prefix_seq_len), device=device, dtype=causal_mask.dtype
-                            ),
-                            causal_mask,
-                        ],
-                        axis=-1,
-                    )
-
-                extended_attention_mask = causal_mask[:, None, :, :] * attention_mask[:, None, None, :]
-            else:
-                extended_attention_mask = attention_mask[:, None, None, :]
-        else:
-            raise ValueError(
-                "Wrong shape for input_ids (shape {}) or attention_mask (shape {})".format(
-                    input_shape, attention_mask.shape
-                )
-            )
-
-        # Since attention_mask is 1.0 for positions we want to attend and 0.0 for
-        # masked positions, this operation will create a tensor which is 0.0 for
-        # positions we want to attend and -10000.0 for masked positions.
-        # Since we are adding it to the raw scores before the softmax, this is
-        # effectively the same as removing these entirely.
-        extended_attention_mask = extended_attention_mask.to(dtype=self.dtype)  # fp16 compatibility
-        extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0
-        return extended_attention_mask
-    
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        token_type_ids=None,
-        position_ids=None,
-        head_mask=None,
-        inputs_embeds=None,
-        encoder_embeds=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_values=None,
-        use_cache=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-        is_decoder=False,
-        mode='multi_modal',
-    ):
-        r"""
-        encoder_hidden_states  (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):
-            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
-            the model is configured as a decoder.
-        encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
-            Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
-            the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``:
-            - 1 for tokens that are **not masked**,
-            - 0 for tokens that are **masked**.
-        past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
-            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
-            If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids`
-            (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)`
-            instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`.
-        use_cache (:obj:`bool`, `optional`):
-            If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up
-            decoding (see :obj:`past_key_values`).
-        """
-        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
-        output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
-        )
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        if is_decoder:
-            use_cache = use_cache if use_cache is not None else self.config.use_cache
-        else:
-            use_cache = False
-
-        if input_ids is not None and inputs_embeds is not None:
-            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
-        elif input_ids is not None:
-            input_shape = input_ids.size()
-            batch_size, seq_length = input_shape
-            device = input_ids.device
-        elif inputs_embeds is not None:
-            input_shape = inputs_embeds.size()[:-1]
-            batch_size, seq_length = input_shape
-            device = inputs_embeds.device
-        elif encoder_embeds is not None:    
-            input_shape = encoder_embeds.size()[:-1]
-            batch_size, seq_length = input_shape 
-            device = encoder_embeds.device
-        else:
-            raise ValueError("You have to specify either input_ids or inputs_embeds or encoder_embeds")
-
-        # past_key_values_length
-        past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
-
-        if attention_mask is None:
-            attention_mask = torch.ones(((batch_size, seq_length + past_key_values_length)), device=device)
-        if token_type_ids is None:
-            token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device)
-
-        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
-        # ourselves in which case we just need to make it broadcastable to all heads.
-        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(attention_mask, input_shape, 
-                                                                                 device, is_decoder)
-
-        # If a 2D or 3D attention mask is provided for the cross-attention
-        # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
-        if encoder_hidden_states is not None:
-            if type(encoder_hidden_states) == list:
-                encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states[0].size()
-            else:
-                encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
-            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
-            
-            if type(encoder_attention_mask) == list:
-                encoder_extended_attention_mask = [self.invert_attention_mask(mask) for mask in encoder_attention_mask]
-            elif encoder_attention_mask is None:
-                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
-                encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
-            else:    
-                encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
-        else:
-            encoder_extended_attention_mask = None
-
-        # Prepare head mask if needed
-        # 1.0 in head_mask indicate we keep the head
-        # attention_probs has shape bsz x n_heads x N x N
-        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
-        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
-        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
-        
-        if encoder_embeds is None:
-            embedding_output = self.embeddings(
-                input_ids=input_ids,
-                position_ids=position_ids,
-                token_type_ids=token_type_ids,
-                inputs_embeds=inputs_embeds,
-                past_key_values_length=past_key_values_length,
-            )
-        else:
-            embedding_output = encoder_embeds
-            
-        encoder_outputs = self.encoder(
-            embedding_output,
-            attention_mask=extended_attention_mask,
-            head_mask=head_mask,
-            encoder_hidden_states=encoder_hidden_states,
-            encoder_attention_mask=encoder_extended_attention_mask,
-            past_key_values=past_key_values,
-            use_cache=use_cache,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-            mode=mode,
-        )
-        sequence_output = encoder_outputs[0]
-        pooled_output = self.pooler(sequence_output) if self.pooler is not None else None
-
-        if not return_dict:
-            return (sequence_output, pooled_output) + encoder_outputs[1:]
-
-        return BaseModelOutputWithPoolingAndCrossAttentions(
-            last_hidden_state=sequence_output,
-            pooler_output=pooled_output,
-            past_key_values=encoder_outputs.past_key_values,
-            hidden_states=encoder_outputs.hidden_states,
-            attentions=encoder_outputs.attentions,
-            cross_attentions=encoder_outputs.cross_attentions,
-        )
-
-
-@add_start_docstrings(
-    """
-    Bert Model with two heads on top as done during the pretraining: a `masked language modeling` head and a `next
-    sentence prediction (classification)` head.
-    """,
-    BERT_START_DOCSTRING,
-)
-class BertForPreTraining(BertPreTrainedModel):
-    def __init__(self, config):
-        super().__init__(config)
-
-        self.bert = BertModel(config)
-        self.cls = BertPreTrainingHeads(config)
-
-        self.init_weights()
-
-    def get_output_embeddings(self):
-        return self.cls.predictions.decoder
-
-    def set_output_embeddings(self, new_embeddings):
-        self.cls.predictions.decoder = new_embeddings
-
-    @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
-    @replace_return_docstrings(output_type=BertForPreTrainingOutput, config_class=_CONFIG_FOR_DOC)
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        token_type_ids=None,
-        position_ids=None,
-        head_mask=None,
-        inputs_embeds=None,
-        labels=None,
-        next_sentence_label=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-    ):
-        r"""
-        labels (:obj:`torch.LongTensor` of shape ``(batch_size, sequence_length)``, `optional`):
-            Labels for computing the masked language modeling loss. Indices should be in ``[-100, 0, ...,
-            config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are ignored
-            (masked), the loss is only computed for the tokens with labels in ``[0, ..., config.vocab_size]``
-        next_sentence_label (``torch.LongTensor`` of shape ``(batch_size,)``, `optional`):
-            Labels for computing the next sequence prediction (classification) loss. Input should be a sequence pair
-            (see :obj:`input_ids` docstring) Indices should be in ``[0, 1]``:
-            - 0 indicates sequence B is a continuation of sequence A,
-            - 1 indicates sequence B is a random sequence.
-        kwargs (:obj:`Dict[str, any]`, optional, defaults to `{}`):
-            Used to hide legacy arguments that have been deprecated.
-        Returns:
-        Example::
-            >>> from transformers import BertTokenizer, BertForPreTraining
-            >>> import torch
-            >>> tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
-            >>> model = BertForPreTraining.from_pretrained('bert-base-uncased')
-            >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
-            >>> outputs = model(**inputs)
-            >>> prediction_logits = outputs.prediction_logits
-            >>> seq_relationship_logits = outputs.seq_relationship_logits
-        """
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            token_type_ids=token_type_ids,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            inputs_embeds=inputs_embeds,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-
-        sequence_output, pooled_output = outputs[:2]
-        prediction_scores, seq_relationship_score = self.cls(sequence_output, pooled_output)
-
-        total_loss = None
-        if labels is not None and next_sentence_label is not None:
-            loss_fct = CrossEntropyLoss()
-            masked_lm_loss = loss_fct(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
-            next_sentence_loss = loss_fct(seq_relationship_score.view(-1, 2), next_sentence_label.view(-1))
-            total_loss = masked_lm_loss + next_sentence_loss
-
-        if not return_dict:
-            output = (prediction_scores, seq_relationship_score) + outputs[2:]
-            return ((total_loss,) + output) if total_loss is not None else output
-
-        return BertForPreTrainingOutput(
-            loss=total_loss,
-            prediction_logits=prediction_scores,
-            seq_relationship_logits=seq_relationship_score,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
-
-
-@add_start_docstrings(
-    """Bert Model with a `language modeling` head on top for CLM fine-tuning. """, BERT_START_DOCSTRING
-)
-class BertLMHeadModel(BertPreTrainedModel):
-
-    _keys_to_ignore_on_load_unexpected = [r"pooler"]
-    _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias"]
-
-    def __init__(self, config):
-        super().__init__(config)
-
-        self.bert = BertModel(config, add_pooling_layer=False)
-        self.cls = BertOnlyMLMHead(config)
-
-        self.init_weights()
-
-    def get_output_embeddings(self):
-        return self.cls.predictions.decoder
-
-    def set_output_embeddings(self, new_embeddings):
-        self.cls.predictions.decoder = new_embeddings
-
-    @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
-    @replace_return_docstrings(output_type=CausalLMOutputWithCrossAttentions, config_class=_CONFIG_FOR_DOC)
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        token_type_ids=None,
-        position_ids=None,
-        head_mask=None,
-        inputs_embeds=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        labels=None,
-        past_key_values=None,
-        use_cache=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-        is_decoder=True,
-        reduction='mean',
-        mode='multi_modal',
-        soft_labels=None,
-        alpha=0,
-        return_logits=False,        
-    ):
-        r"""
-        encoder_hidden_states  (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):
-            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
-            the model is configured as a decoder.
-        encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
-            Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
-            the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``:
-            - 1 for tokens that are **not masked**,
-            - 0 for tokens that are **masked**.
-        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
-            Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in
-            ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are
-            ignored (masked), the loss is only computed for the tokens with labels n ``[0, ..., config.vocab_size]``
-        past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
-            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
-            If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids`
-            (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)`
-            instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`.
-        use_cache (:obj:`bool`, `optional`):
-            If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up
-            decoding (see :obj:`past_key_values`).
-        Returns:
-        Example::
-            >>> from transformers import BertTokenizer, BertLMHeadModel, BertConfig
-            >>> import torch
-            >>> tokenizer = BertTokenizer.from_pretrained('bert-base-cased')
-            >>> config = BertConfig.from_pretrained("bert-base-cased")
-            >>> model = BertLMHeadModel.from_pretrained('bert-base-cased', config=config)
-            >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
-            >>> outputs = model(**inputs)
-            >>> prediction_logits = outputs.logits
-        """
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-        if labels is not None:
-            use_cache = False
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            token_type_ids=token_type_ids,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            inputs_embeds=inputs_embeds,
-            encoder_hidden_states=encoder_hidden_states,
-            encoder_attention_mask=encoder_attention_mask,
-            past_key_values=past_key_values,
-            use_cache=use_cache,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-            is_decoder=is_decoder,
-            mode=mode,
-        )
-        
-        sequence_output = outputs[0]
-        prediction_scores = self.cls(sequence_output)
-        
-        if return_logits:
-            return prediction_scores[:, :-1, :].contiguous()  
-
-        lm_loss = None
-        if labels is not None:
-            # we are doing next-token prediction; shift prediction scores and input ids by one
-            shifted_prediction_scores = prediction_scores[:, :-1, :].contiguous()
-            labels = labels[:, 1:].contiguous()
-            loss_fct = CrossEntropyLoss(reduction=reduction)
-            lm_loss = loss_fct(shifted_prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
-            lm_loss = lm_loss.view(prediction_scores.size(0),-1).sum(1)
-            
-        if soft_labels is not None:
-            loss_distill = -torch.sum(F.log_softmax(shifted_prediction_scores, dim=-1)*soft_labels,dim=-1)
-            loss_distill = (loss_distill * (labels!=-100)).sum(1)
-            lm_loss = (1-alpha)*lm_loss + alpha*loss_distill                    
-
-        if not return_dict:
-            output = (prediction_scores,) + outputs[2:]
-            return ((lm_loss,) + output) if lm_loss is not None else output
-
-        return CausalLMOutputWithCrossAttentions(
-            loss=lm_loss,
-            logits=prediction_scores,
-            past_key_values=outputs.past_key_values,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-            cross_attentions=outputs.cross_attentions,
-        )
-
-    def prepare_inputs_for_generation(self, input_ids, past=None, attention_mask=None, **model_kwargs):
-        input_shape = input_ids.shape
-        # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly
-        if attention_mask is None:
-            attention_mask = input_ids.new_ones(input_shape)
-
-        # cut decoder_input_ids if past is used
-        if past is not None:
-            input_ids = input_ids[:, -1:]
-
-        return {
-            "input_ids": input_ids, 
-            "attention_mask": attention_mask, 
-            "past_key_values": past,
-            "encoder_hidden_states": model_kwargs.get("encoder_hidden_states", None),
-            "encoder_attention_mask": model_kwargs.get("encoder_attention_mask", None),
-            "is_decoder": True,
-        }
-
-    def _reorder_cache(self, past, beam_idx):
-        reordered_past = ()
-        for layer_past in past:
-            reordered_past += (tuple(past_state.index_select(0, beam_idx) for past_state in layer_past),)
-        return reordered_past
-
-
-@add_start_docstrings("""Bert Model with a `language modeling` head on top. """, BERT_START_DOCSTRING)
-class BertForMaskedLM(BertPreTrainedModel):
-
-    _keys_to_ignore_on_load_unexpected = [r"pooler"]
-    _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias"]
-
-    def __init__(self, config):
-        super().__init__(config)
-
-        self.bert = BertModel(config, add_pooling_layer=False)
-        self.cls = BertOnlyMLMHead(config)
-
-        self.init_weights()
-
-    def get_output_embeddings(self):
-        return self.cls.predictions.decoder
-
-    def set_output_embeddings(self, new_embeddings):
-        self.cls.predictions.decoder = new_embeddings
-
-    @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
-    @add_code_sample_docstrings(
-        tokenizer_class=_TOKENIZER_FOR_DOC,
-        checkpoint="bert-base-uncased",
-        output_type=MaskedLMOutput,
-        config_class=_CONFIG_FOR_DOC,
-    )
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        token_type_ids=None,
-        position_ids=None,
-        head_mask=None,
-        inputs_embeds=None,
-        encoder_embeds=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        labels=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-        is_decoder=False,
-        mode='multi_modal',
-        soft_labels=None,
-        alpha=0,
-        return_logits=False,
-    ):
-        r"""
-        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
-            Labels for computing the masked language modeling loss. Indices should be in ``[-100, 0, ...,
-            config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are ignored
-            (masked), the loss is only computed for the tokens with labels in ``[0, ..., config.vocab_size]``
-        """
-
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            token_type_ids=token_type_ids,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            inputs_embeds=inputs_embeds,
-            encoder_embeds=encoder_embeds,
-            encoder_hidden_states=encoder_hidden_states,
-            encoder_attention_mask=encoder_attention_mask,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-            is_decoder=is_decoder,
-            mode=mode,
-        )
-
-        sequence_output = outputs[0]
-        prediction_scores = self.cls(sequence_output)
-        
-        if return_logits:
-            return prediction_scores
-
-        masked_lm_loss = None
-        if labels is not None:
-            loss_fct = CrossEntropyLoss()  # -100 index = padding token
-            masked_lm_loss = loss_fct(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
-        
-        if soft_labels is not None:
-            loss_distill = -torch.sum(F.log_softmax(prediction_scores, dim=-1)*soft_labels,dim=-1)
-            loss_distill = loss_distill[labels!=-100].mean()
-            masked_lm_loss = (1-alpha)*masked_lm_loss + alpha*loss_distill
-
-        if not return_dict:
-            output = (prediction_scores,) + outputs[2:]
-            return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output
-
-        return MaskedLMOutput(
-            loss=masked_lm_loss,
-            logits=prediction_scores,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
-
-    def prepare_inputs_for_generation(self, input_ids, attention_mask=None, **model_kwargs):
-        input_shape = input_ids.shape
-        effective_batch_size = input_shape[0]
-
-        #  add a dummy token
-        assert self.config.pad_token_id is not None, "The PAD token should be defined for generation"
-        attention_mask = torch.cat([attention_mask, attention_mask.new_zeros((attention_mask.shape[0], 1))], dim=-1)
-        dummy_token = torch.full(
-            (effective_batch_size, 1), self.config.pad_token_id, dtype=torch.long, device=input_ids.device
-        )
-        input_ids = torch.cat([input_ids, dummy_token], dim=1)
-
-        return {"input_ids": input_ids, "attention_mask": attention_mask}
-
-
-@add_start_docstrings(
-    """Bert Model with a `next sentence prediction (classification)` head on top. """,
-    BERT_START_DOCSTRING,
-)
-class BertForNextSentencePrediction(BertPreTrainedModel):
-    def __init__(self, config):
-        super().__init__(config)
-
-        self.bert = BertModel(config)
-        self.cls = BertOnlyNSPHead(config)
-
-        self.init_weights()
-
-    @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
-    @replace_return_docstrings(output_type=NextSentencePredictorOutput, config_class=_CONFIG_FOR_DOC)
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        token_type_ids=None,
-        position_ids=None,
-        head_mask=None,
-        inputs_embeds=None,
-        labels=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-        **kwargs
-    ):
-        r"""
-        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
-            Labels for computing the next sequence prediction (classification) loss. Input should be a sequence pair
-            (see ``input_ids`` docstring). Indices should be in ``[0, 1]``:
-            - 0 indicates sequence B is a continuation of sequence A,
-            - 1 indicates sequence B is a random sequence.
-        Returns:
-        Example::
-            >>> from transformers import BertTokenizer, BertForNextSentencePrediction
-            >>> import torch
-            >>> tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
-            >>> model = BertForNextSentencePrediction.from_pretrained('bert-base-uncased')
-            >>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
-            >>> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
-            >>> encoding = tokenizer(prompt, next_sentence, return_tensors='pt')
-            >>> outputs = model(**encoding, labels=torch.LongTensor([1]))
-            >>> logits = outputs.logits
-            >>> assert logits[0, 0] < logits[0, 1] # next sentence was random
-        """
-
-        if "next_sentence_label" in kwargs:
-            warnings.warn(
-                "The `next_sentence_label` argument is deprecated and will be removed in a future version, use `labels` instead.",
-                FutureWarning,
-            )
-            labels = kwargs.pop("next_sentence_label")
-
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            token_type_ids=token_type_ids,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            inputs_embeds=inputs_embeds,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-
-        pooled_output = outputs[1]
-
-        seq_relationship_scores = self.cls(pooled_output)
-
-        next_sentence_loss = None
-        if labels is not None:
-            loss_fct = CrossEntropyLoss()
-            next_sentence_loss = loss_fct(seq_relationship_scores.view(-1, 2), labels.view(-1))
-
-        if not return_dict:
-            output = (seq_relationship_scores,) + outputs[2:]
-            return ((next_sentence_loss,) + output) if next_sentence_loss is not None else output
-
-        return NextSentencePredictorOutput(
-            loss=next_sentence_loss,
-            logits=seq_relationship_scores,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
-
-
-@add_start_docstrings(
-    """
-    Bert Model transformer with a sequence classification/regression head on top (a linear layer on top of the pooled
-    output) e.g. for GLUE tasks.
-    """,
-    BERT_START_DOCSTRING,
-)
-class BertForSequenceClassification(BertPreTrainedModel):
-    def __init__(self, config):
-        super().__init__(config)
-        self.num_labels = config.num_labels
-
-        self.bert = BertModel(config)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
-
-        self.init_weights()
-
-    @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
-    @add_code_sample_docstrings(
-        tokenizer_class=_TOKENIZER_FOR_DOC,
-        checkpoint="bert-base-uncased",
-        output_type=SequenceClassifierOutput,
-        config_class=_CONFIG_FOR_DOC,
-    )
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        token_type_ids=None,
-        position_ids=None,
-        head_mask=None,
-        inputs_embeds=None,
-        labels=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-    ):
-        r"""
-        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
-            Labels for computing the sequence classification/regression loss. Indices should be in :obj:`[0, ...,
-            config.num_labels - 1]`. If :obj:`config.num_labels == 1` a regression loss is computed (Mean-Square loss),
-            If :obj:`config.num_labels > 1` a classification loss is computed (Cross-Entropy).
-        """
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            token_type_ids=token_type_ids,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            inputs_embeds=inputs_embeds,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-
-        pooled_output = outputs[1]
-
-        pooled_output = self.dropout(pooled_output)
-        logits = self.classifier(pooled_output)
-
-        loss = None
-        if labels is not None:
-            if self.num_labels == 1:
-                #  We are doing regression
-                loss_fct = MSELoss()
-                loss = loss_fct(logits.view(-1), labels.view(-1))
-            else:
-                loss_fct = CrossEntropyLoss()
-                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
-
-        if not return_dict:
-            output = (logits,) + outputs[2:]
-            return ((loss,) + output) if loss is not None else output
-
-        return SequenceClassifierOutput(
-            loss=loss,
-            logits=logits,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
-
-
-@add_start_docstrings(
-    """
-    Bert Model with a multiple choice classification head on top (a linear layer on top of the pooled output and a
-    softmax) e.g. for RocStories/SWAG tasks.
-    """,
-    BERT_START_DOCSTRING,
-)
-class BertForMultipleChoice(BertPreTrainedModel):
-    def __init__(self, config):
-        super().__init__(config)
-
-        self.bert = BertModel(config)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        self.classifier = nn.Linear(config.hidden_size, 1)
-
-        self.init_weights()
-
-    @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, num_choices, sequence_length"))
-    @add_code_sample_docstrings(
-        tokenizer_class=_TOKENIZER_FOR_DOC,
-        checkpoint="bert-base-uncased",
-        output_type=MultipleChoiceModelOutput,
-        config_class=_CONFIG_FOR_DOC,
-    )
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        token_type_ids=None,
-        position_ids=None,
-        head_mask=None,
-        inputs_embeds=None,
-        labels=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-    ):
-        r"""
-        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
-            Labels for computing the multiple choice classification loss. Indices should be in ``[0, ...,
-            num_choices-1]`` where :obj:`num_choices` is the size of the second dimension of the input tensors. (See
-            :obj:`input_ids` above)
-        """
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-        num_choices = input_ids.shape[1] if input_ids is not None else inputs_embeds.shape[1]
-
-        input_ids = input_ids.view(-1, input_ids.size(-1)) if input_ids is not None else None
-        attention_mask = attention_mask.view(-1, attention_mask.size(-1)) if attention_mask is not None else None
-        token_type_ids = token_type_ids.view(-1, token_type_ids.size(-1)) if token_type_ids is not None else None
-        position_ids = position_ids.view(-1, position_ids.size(-1)) if position_ids is not None else None
-        inputs_embeds = (
-            inputs_embeds.view(-1, inputs_embeds.size(-2), inputs_embeds.size(-1))
-            if inputs_embeds is not None
-            else None
-        )
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            token_type_ids=token_type_ids,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            inputs_embeds=inputs_embeds,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-
-        pooled_output = outputs[1]
-
-        pooled_output = self.dropout(pooled_output)
-        logits = self.classifier(pooled_output)
-        reshaped_logits = logits.view(-1, num_choices)
-
-        loss = None
-        if labels is not None:
-            loss_fct = CrossEntropyLoss()
-            loss = loss_fct(reshaped_logits, labels)
-
-        if not return_dict:
-            output = (reshaped_logits,) + outputs[2:]
-            return ((loss,) + output) if loss is not None else output
-
-        return MultipleChoiceModelOutput(
-            loss=loss,
-            logits=reshaped_logits,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
-
-
-@add_start_docstrings(
-    """
-    Bert Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for
-    Named-Entity-Recognition (NER) tasks.
-    """,
-    BERT_START_DOCSTRING,
-)
-class BertForTokenClassification(BertPreTrainedModel):
-
-    _keys_to_ignore_on_load_unexpected = [r"pooler"]
-
-    def __init__(self, config):
-        super().__init__(config)
-        self.num_labels = config.num_labels
-
-        self.bert = BertModel(config, add_pooling_layer=False)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
-
-        self.init_weights()
-
-    @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
-    @add_code_sample_docstrings(
-        tokenizer_class=_TOKENIZER_FOR_DOC,
-        checkpoint="bert-base-uncased",
-        output_type=TokenClassifierOutput,
-        config_class=_CONFIG_FOR_DOC,
-    )
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        token_type_ids=None,
-        position_ids=None,
-        head_mask=None,
-        inputs_embeds=None,
-        labels=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-    ):
-        r"""
-        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
-            Labels for computing the token classification loss. Indices should be in ``[0, ..., config.num_labels -
-            1]``.
-        """
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            token_type_ids=token_type_ids,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            inputs_embeds=inputs_embeds,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-
-        sequence_output = outputs[0]
-
-        sequence_output = self.dropout(sequence_output)
-        logits = self.classifier(sequence_output)
-
-        loss = None
-        if labels is not None:
-            loss_fct = CrossEntropyLoss()
-            # Only keep active parts of the loss
-            if attention_mask is not None:
-                active_loss = attention_mask.view(-1) == 1
-                active_logits = logits.view(-1, self.num_labels)
-                active_labels = torch.where(
-                    active_loss, labels.view(-1), torch.tensor(loss_fct.ignore_index).type_as(labels)
-                )
-                loss = loss_fct(active_logits, active_labels)
-            else:
-                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
-
-        if not return_dict:
-            output = (logits,) + outputs[2:]
-            return ((loss,) + output) if loss is not None else output
-
-        return TokenClassifierOutput(
-            loss=loss,
-            logits=logits,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
-
-
-@add_start_docstrings(
-    """
-    Bert Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear
-    layers on top of the hidden-states output to compute `span start logits` and `span end logits`).
-    """,
-    BERT_START_DOCSTRING,
-)
-class BertForQuestionAnswering(BertPreTrainedModel):
-
-    _keys_to_ignore_on_load_unexpected = [r"pooler"]
-
-    def __init__(self, config):
-        super().__init__(config)
-        self.num_labels = config.num_labels
-
-        self.bert = BertModel(config, add_pooling_layer=False)
-        self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)
-
-        self.init_weights()
-
-    @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
-    @add_code_sample_docstrings(
-        tokenizer_class=_TOKENIZER_FOR_DOC,
-        checkpoint="bert-base-uncased",
-        output_type=QuestionAnsweringModelOutput,
-        config_class=_CONFIG_FOR_DOC,
-    )
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        token_type_ids=None,
-        position_ids=None,
-        head_mask=None,
-        inputs_embeds=None,
-        start_positions=None,
-        end_positions=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-    ):
-        r"""
-        start_positions (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
-            Labels for position (index) of the start of the labelled span for computing the token classification loss.
-            Positions are clamped to the length of the sequence (:obj:`sequence_length`). Position outside of the
-            sequence are not taken into account for computing the loss.
-        end_positions (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
-            Labels for position (index) of the end of the labelled span for computing the token classification loss.
-            Positions are clamped to the length of the sequence (:obj:`sequence_length`). Position outside of the
-            sequence are not taken into account for computing the loss.
-        """
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            token_type_ids=token_type_ids,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            inputs_embeds=inputs_embeds,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-
-        sequence_output = outputs[0]
-
-        logits = self.qa_outputs(sequence_output)
-        start_logits, end_logits = logits.split(1, dim=-1)
-        start_logits = start_logits.squeeze(-1)
-        end_logits = end_logits.squeeze(-1)
-
-        total_loss = None
-        if start_positions is not None and end_positions is not None:
-            # If we are on multi-GPU, split add a dimension
-            if len(start_positions.size()) > 1:
-                start_positions = start_positions.squeeze(-1)
-            if len(end_positions.size()) > 1:
-                end_positions = end_positions.squeeze(-1)
-            # sometimes the start/end positions are outside our model inputs, we ignore these terms
-            ignored_index = start_logits.size(1)
-            start_positions.clamp_(0, ignored_index)
-            end_positions.clamp_(0, ignored_index)
-
-            loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
-            start_loss = loss_fct(start_logits, start_positions)
-            end_loss = loss_fct(end_logits, end_positions)
-            total_loss = (start_loss + end_loss) / 2
-
-        if not return_dict:
-            output = (start_logits, end_logits) + outputs[2:]
-            return ((total_loss,) + output) if total_loss is not None else output
-
-        return QuestionAnsweringModelOutput(
-            loss=total_loss,
-            start_logits=start_logits,
-            end_logits=end_logits,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
diff --git a/spaces/Purple11/Grounded-Diffusion/src/CLIP/clip/simple_tokenizer.py b/spaces/Purple11/Grounded-Diffusion/src/CLIP/clip/simple_tokenizer.py
deleted file mode 100644
index 0a66286b7d5019c6e221932a813768038f839c91..0000000000000000000000000000000000000000
--- a/spaces/Purple11/Grounded-Diffusion/src/CLIP/clip/simple_tokenizer.py
+++ /dev/null
@@ -1,132 +0,0 @@
-import gzip
-import html
-import os
-from functools import lru_cache
-
-import ftfy
-import regex as re
-
-
-@lru_cache()
-def default_bpe():
-    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz")
-
-
-@lru_cache()
-def bytes_to_unicode():
-    """
-    Returns list of utf-8 byte and a corresponding list of unicode strings.
-    The reversible bpe codes work on unicode strings.
-    This means you need a large # of unicode characters in your vocab if you want to avoid UNKs.
-    When you're at something like a 10B token dataset you end up needing around 5K for decent coverage.
-    This is a signficant percentage of your normal, say, 32K bpe vocab.
-    To avoid that, we want lookup tables between utf-8 bytes and unicode strings.
-    And avoids mapping to whitespace/control characters the bpe code barfs on.
-    """
-    bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1))
-    cs = bs[:]
-    n = 0
-    for b in range(2**8):
-        if b not in bs:
-            bs.append(b)
-            cs.append(2**8+n)
-            n += 1
-    cs = [chr(n) for n in cs]
-    return dict(zip(bs, cs))
-
-
-def get_pairs(word):
-    """Return set of symbol pairs in a word.
-    Word is represented as tuple of symbols (symbols being variable-length strings).
-    """
-    pairs = set()
-    prev_char = word[0]
-    for char in word[1:]:
-        pairs.add((prev_char, char))
-        prev_char = char
-    return pairs
-
-
-def basic_clean(text):
-    text = ftfy.fix_text(text)
-    text = html.unescape(html.unescape(text))
-    return text.strip()
-
-
-def whitespace_clean(text):
-    text = re.sub(r'\s+', ' ', text)
-    text = text.strip()
-    return text
-
-
-class SimpleTokenizer(object):
-    def __init__(self, bpe_path: str = default_bpe()):
-        self.byte_encoder = bytes_to_unicode()
-        self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}
-        merges = gzip.open(bpe_path).read().decode("utf-8").split('\n')
-        merges = merges[1:49152-256-2+1]
-        merges = [tuple(merge.split()) for merge in merges]
-        vocab = list(bytes_to_unicode().values())
-        vocab = vocab + [v+'</w>' for v in vocab]
-        for merge in merges:
-            vocab.append(''.join(merge))
-        vocab.extend(['<|startoftext|>', '<|endoftext|>'])
-        self.encoder = dict(zip(vocab, range(len(vocab))))
-        self.decoder = {v: k for k, v in self.encoder.items()}
-        self.bpe_ranks = dict(zip(merges, range(len(merges))))
-        self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'}
-        self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE)
-
-    def bpe(self, token):
-        if token in self.cache:
-            return self.cache[token]
-        word = tuple(token[:-1]) + ( token[-1] + '</w>',)
-        pairs = get_pairs(word)
-
-        if not pairs:
-            return token+'</w>'
-
-        while True:
-            bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf')))
-            if bigram not in self.bpe_ranks:
-                break
-            first, second = bigram
-            new_word = []
-            i = 0
-            while i < len(word):
-                try:
-                    j = word.index(first, i)
-                    new_word.extend(word[i:j])
-                    i = j
-                except:
-                    new_word.extend(word[i:])
-                    break
-
-                if word[i] == first and i < len(word)-1 and word[i+1] == second:
-                    new_word.append(first+second)
-                    i += 2
-                else:
-                    new_word.append(word[i])
-                    i += 1
-            new_word = tuple(new_word)
-            word = new_word
-            if len(word) == 1:
-                break
-            else:
-                pairs = get_pairs(word)
-        word = ' '.join(word)
-        self.cache[token] = word
-        return word
-
-    def encode(self, text):
-        bpe_tokens = []
-        text = whitespace_clean(basic_clean(text)).lower()
-        for token in re.findall(self.pat, text):
-            token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8'))
-            bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' '))
-        return bpe_tokens
-
-    def decode(self, tokens):
-        text = ''.join([self.decoder[token] for token in tokens])
-        text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('</w>', ' ')
-        return text
diff --git a/spaces/QianFeng/White-box-Cartoonization2308/wbc/cartoonize.py b/spaces/QianFeng/White-box-Cartoonization2308/wbc/cartoonize.py
deleted file mode 100644
index 25faf1ceb95aaed9a3f7a7982d17a03dc6bc32b1..0000000000000000000000000000000000000000
--- a/spaces/QianFeng/White-box-Cartoonization2308/wbc/cartoonize.py
+++ /dev/null
@@ -1,112 +0,0 @@
-import os
-import cv2
-import numpy as np
-import tensorflow as tf
-import wbc.network as network
-import wbc.guided_filter as guided_filter
-from tqdm import tqdm
-
-
-def resize_crop(image):
-    h, w, c = np.shape(image)
-    if min(h, w) > 720:
-        if h > w:
-            h, w = int(720 * h / w), 720
-        else:
-            h, w = 720, int(720 * w / h)
-    image = cv2.resize(image, (w, h),
-                       interpolation=cv2.INTER_AREA)
-    h, w = (h // 8) * 8, (w // 8) * 8
-    image = image[:h, :w, :]
-    return image
-
-
-def cartoonize(load_folder, save_folder, model_path):
-    print(model_path)
-    input_photo = tf.placeholder(tf.float32, [1, None, None, 3])
-    network_out = network.unet_generator(input_photo)
-    final_out = guided_filter.guided_filter(input_photo, network_out, r=1, eps=5e-3)
-
-    all_vars = tf.trainable_variables()
-    gene_vars = [var for var in all_vars if 'generator' in var.name]
-    saver = tf.train.Saver(var_list=gene_vars)
-
-    config = tf.ConfigProto()
-    config.gpu_options.allow_growth = True
-    sess = tf.Session(config=config)
-
-    sess.run(tf.global_variables_initializer())
-    saver.restore(sess, tf.train.latest_checkpoint(model_path))
-    name_list = os.listdir(load_folder)
-    for name in tqdm(name_list):
-        try:
-            load_path = os.path.join(load_folder, name)
-            save_path = os.path.join(save_folder, name)
-            image = cv2.imread(load_path)
-            image = resize_crop(image)
-            batch_image = image.astype(np.float32) / 127.5 - 1
-            batch_image = np.expand_dims(batch_image, axis=0)
-            output = sess.run(final_out, feed_dict={input_photo: batch_image})
-            output = (np.squeeze(output) + 1) * 127.5
-            output = np.clip(output, 0, 255).astype(np.uint8)
-            cv2.imwrite(save_path, output)
-        except:
-            print('cartoonize {} failed'.format(load_path))
-
-
-class Cartoonize:
-    def __init__(self, model_path):
-        print(model_path)
-        self.input_photo = tf.placeholder(tf.float32, [1, None, None, 3])
-        network_out = network.unet_generator(self.input_photo)
-        self.final_out = guided_filter.guided_filter(self.input_photo, network_out, r=1, eps=5e-3)
-
-        all_vars = tf.trainable_variables()
-        gene_vars = [var for var in all_vars if 'generator' in var.name]
-        saver = tf.train.Saver(var_list=gene_vars)
-
-        config = tf.ConfigProto()
-        config.gpu_options.allow_growth = True
-        self.sess = tf.Session(config=config)
-
-        self.sess.run(tf.global_variables_initializer())
-        saver.restore(self.sess, tf.train.latest_checkpoint(model_path))
-
-    def run(self, load_folder, save_folder):
-        name_list = os.listdir(load_folder)
-        for name in tqdm(name_list):
-            try:
-                load_path = os.path.join(load_folder, name)
-                save_path = os.path.join(save_folder, name)
-                image = cv2.imread(load_path)
-                image = resize_crop(image)
-                batch_image = image.astype(np.float32) / 127.5 - 1
-                batch_image = np.expand_dims(batch_image, axis=0)
-                output = self.sess.run(self.final_out, feed_dict={self.input_photo: batch_image})
-                output = (np.squeeze(output) + 1) * 127.5
-                output = np.clip(output, 0, 255).astype(np.uint8)
-                cv2.imwrite(save_path, output)
-            except:
-                print('cartoonize {} failed'.format(load_path))
-
-    def run_sigle(self, load_path, save_path):
-        try:
-            image = cv2.imread(load_path)
-            image = resize_crop(image)
-            batch_image = image.astype(np.float32) / 127.5 - 1
-            batch_image = np.expand_dims(batch_image, axis=0)
-            output = self.sess.run(self.final_out, feed_dict={self.input_photo: batch_image})
-            output = (np.squeeze(output) + 1) * 127.5
-            output = np.clip(output, 0, 255).astype(np.uint8)
-            cv2.imwrite(save_path, output)
-        except:
-            print('cartoonize {} failed'.format(load_path))
-
-
-if __name__ == '__main__':
-    model_path = 'saved_models'
-    load_folder = 'test_images'
-    save_folder = 'cartoonized_images'
-    if not os.path.exists(save_folder):
-        os.mkdir(save_folder)
-    cartoonize(load_folder, save_folder, model_path)
diff --git a/spaces/Raghvender/VideoCaptionWhisper/README.md b/spaces/Raghvender/VideoCaptionWhisper/README.md
deleted file mode 100644
index 7e44465ba164cc1e9a742b4b9f9eda7a4235bdc9..0000000000000000000000000000000000000000
--- a/spaces/Raghvender/VideoCaptionWhisper/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: VideoCaptionWhisper
-emoji: 💩
-colorFrom: green
-colorTo: gray
-sdk: gradio
-sdk_version: 3.21.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/RamAnanth1/T2I-Adapter/ldm/modules/losses/vqperceptual.py b/spaces/RamAnanth1/T2I-Adapter/ldm/modules/losses/vqperceptual.py
deleted file mode 100644
index f69981769e4bd5462600458c4fcf26620f7e4306..0000000000000000000000000000000000000000
--- a/spaces/RamAnanth1/T2I-Adapter/ldm/modules/losses/vqperceptual.py
+++ /dev/null
@@ -1,167 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-from einops import repeat
-
-from taming.modules.discriminator.model import NLayerDiscriminator, weights_init
-from taming.modules.losses.lpips import LPIPS
-from taming.modules.losses.vqperceptual import hinge_d_loss, vanilla_d_loss
-
-
-def hinge_d_loss_with_exemplar_weights(logits_real, logits_fake, weights):
-    assert weights.shape[0] == logits_real.shape[0] == logits_fake.shape[0]
-    loss_real = torch.mean(F.relu(1. - logits_real), dim=[1,2,3])
-    loss_fake = torch.mean(F.relu(1. + logits_fake), dim=[1,2,3])
-    loss_real = (weights * loss_real).sum() / weights.sum()
-    loss_fake = (weights * loss_fake).sum() / weights.sum()
-    d_loss = 0.5 * (loss_real + loss_fake)
-    return d_loss
-
-def adopt_weight(weight, global_step, threshold=0, value=0.):
-    if global_step < threshold:
-        weight = value
-    return weight
-
-
-def measure_perplexity(predicted_indices, n_embed):
-    # src: https://github.com/karpathy/deep-vector-quantization/blob/main/model.py
-    # eval cluster perplexity. when perplexity == num_embeddings then all clusters are used exactly equally
-    encodings = F.one_hot(predicted_indices, n_embed).float().reshape(-1, n_embed)
-    avg_probs = encodings.mean(0)
-    perplexity = (-(avg_probs * torch.log(avg_probs + 1e-10)).sum()).exp()
-    cluster_use = torch.sum(avg_probs > 0)
-    return perplexity, cluster_use
-
-def l1(x, y):
-    return torch.abs(x-y)
-
-
-def l2(x, y):
-    return torch.pow((x-y), 2)
-
-
-class VQLPIPSWithDiscriminator(nn.Module):
-    def __init__(self, disc_start, codebook_weight=1.0, pixelloss_weight=1.0,
-                 disc_num_layers=3, disc_in_channels=3, disc_factor=1.0, disc_weight=1.0,
-                 perceptual_weight=1.0, use_actnorm=False, disc_conditional=False,
-                 disc_ndf=64, disc_loss="hinge", n_classes=None, perceptual_loss="lpips",
-                 pixel_loss="l1"):
-        super().__init__()
-        assert disc_loss in ["hinge", "vanilla"]
-        assert perceptual_loss in ["lpips", "clips", "dists"]
-        assert pixel_loss in ["l1", "l2"]
-        self.codebook_weight = codebook_weight
-        self.pixel_weight = pixelloss_weight
-        if perceptual_loss == "lpips":
-            print(f"{self.__class__.__name__}: Running with LPIPS.")
-            self.perceptual_loss = LPIPS().eval()
-        else:
-            raise ValueError(f"Unknown perceptual loss: >> {perceptual_loss} <<")
-        self.perceptual_weight = perceptual_weight
-
-        if pixel_loss == "l1":
-            self.pixel_loss = l1
-        else:
-            self.pixel_loss = l2
-
-        self.discriminator = NLayerDiscriminator(input_nc=disc_in_channels,
-                                                 n_layers=disc_num_layers,
-                                                 use_actnorm=use_actnorm,
-                                                 ndf=disc_ndf
-                                                 ).apply(weights_init)
-        self.discriminator_iter_start = disc_start
-        if disc_loss == "hinge":
-            self.disc_loss = hinge_d_loss
-        elif disc_loss == "vanilla":
-            self.disc_loss = vanilla_d_loss
-        else:
-            raise ValueError(f"Unknown GAN loss '{disc_loss}'.")
-        print(f"VQLPIPSWithDiscriminator running with {disc_loss} loss.")
-        self.disc_factor = disc_factor
-        self.discriminator_weight = disc_weight
-        self.disc_conditional = disc_conditional
-        self.n_classes = n_classes
-
-    def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None):
-        if last_layer is not None:
-            nll_grads = torch.autograd.grad(nll_loss, last_layer, retain_graph=True)[0]
-            g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0]
-        else:
-            nll_grads = torch.autograd.grad(nll_loss, self.last_layer[0], retain_graph=True)[0]
-            g_grads = torch.autograd.grad(g_loss, self.last_layer[0], retain_graph=True)[0]
-
-        d_weight = torch.norm(nll_grads) / (torch.norm(g_grads) + 1e-4)
-        d_weight = torch.clamp(d_weight, 0.0, 1e4).detach()
-        d_weight = d_weight * self.discriminator_weight
-        return d_weight
-
-    def forward(self, codebook_loss, inputs, reconstructions, optimizer_idx,
-                global_step, last_layer=None, cond=None, split="train", predicted_indices=None):
-        if not exists(codebook_loss):
-            codebook_loss = torch.tensor([0.]).to(inputs.device)
-        #rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous())
-        rec_loss = self.pixel_loss(inputs.contiguous(), reconstructions.contiguous())
-        if self.perceptual_weight > 0:
-            p_loss = self.perceptual_loss(inputs.contiguous(), reconstructions.contiguous())
-            rec_loss = rec_loss + self.perceptual_weight * p_loss
-        else:
-            p_loss = torch.tensor([0.0])
-
-        nll_loss = rec_loss
-        #nll_loss = torch.sum(nll_loss) / nll_loss.shape[0]
-        nll_loss = torch.mean(nll_loss)
-
-        # now the GAN part
-        if optimizer_idx == 0:
-            # generator update
-            if cond is None:
-                assert not self.disc_conditional
-                logits_fake = self.discriminator(reconstructions.contiguous())
-            else:
-                assert self.disc_conditional
-                logits_fake = self.discriminator(torch.cat((reconstructions.contiguous(), cond), dim=1))
-            g_loss = -torch.mean(logits_fake)
-
-            try:
-                d_weight = self.calculate_adaptive_weight(nll_loss, g_loss, last_layer=last_layer)
-            except RuntimeError:
-                assert not self.training
-                d_weight = torch.tensor(0.0)
-
-            disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start)
-            loss = nll_loss + d_weight * disc_factor * g_loss + self.codebook_weight * codebook_loss.mean()
-
-            log = {"{}/total_loss".format(split): loss.clone().detach().mean(),
-                   "{}/quant_loss".format(split): codebook_loss.detach().mean(),
-                   "{}/nll_loss".format(split): nll_loss.detach().mean(),
-                   "{}/rec_loss".format(split): rec_loss.detach().mean(),
-                   "{}/p_loss".format(split): p_loss.detach().mean(),
-                   "{}/d_weight".format(split): d_weight.detach(),
-                   "{}/disc_factor".format(split): torch.tensor(disc_factor),
-                   "{}/g_loss".format(split): g_loss.detach().mean(),
-                   }
-            if predicted_indices is not None:
-                assert self.n_classes is not None
-                with torch.no_grad():
-                    perplexity, cluster_usage = measure_perplexity(predicted_indices, self.n_classes)
-                log[f"{split}/perplexity"] = perplexity
-                log[f"{split}/cluster_usage"] = cluster_usage
-            return loss, log
-
-        if optimizer_idx == 1:
-            # second pass for discriminator update
-            if cond is None:
-                logits_real = self.discriminator(inputs.contiguous().detach())
-                logits_fake = self.discriminator(reconstructions.contiguous().detach())
-            else:
-                logits_real = self.discriminator(torch.cat((inputs.contiguous().detach(), cond), dim=1))
-                logits_fake = self.discriminator(torch.cat((reconstructions.contiguous().detach(), cond), dim=1))
-
-            disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start)
-            d_loss = disc_factor * self.disc_loss(logits_real, logits_fake)
-
-            log = {"{}/disc_loss".format(split): d_loss.clone().detach().mean(),
-                   "{}/logits_real".format(split): logits_real.detach().mean(),
-                   "{}/logits_fake".format(split): logits_fake.detach().mean()
-                   }
-            return d_loss, log
diff --git a/spaces/RedBaron5/PatentSolver/App/bin/constants.py b/spaces/RedBaron5/PatentSolver/App/bin/constants.py
deleted file mode 100644
index e3098815491f7f621646078b96858ec731ac6a01..0000000000000000000000000000000000000000
--- a/spaces/RedBaron5/PatentSolver/App/bin/constants.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import os
-import root_folder
-
-ROOT = root_folder.ROOT+"/"
-APP_FOLDER = ROOT+"/App/"
-ASSETS = APP_FOLDER+"assets/"
-DATA = ROOT+"Data/"
-DATA_INPUT = DATA+"input/"
-TEMP = DATA+"temp/"
-CORPUS = DATA+"corpus/"
-PRE = DATA+"pretreated/"
-DATA_OUTPUT = DATA+"output/"
-GRAPH_FOLDER = DATA+"graphs/"
-POLARITY_DATA = ASSETS+"polaritySets/"
diff --git a/spaces/Reeve/Ohayou_Face/criteria/__init__.py b/spaces/Reeve/Ohayou_Face/criteria/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Reha2704/VToonify/vtoonify/smooth_parsing_map.py b/spaces/Reha2704/VToonify/vtoonify/smooth_parsing_map.py
deleted file mode 100644
index 7720d0c7786925db38d3e793d6a3a8f68f6e663e..0000000000000000000000000000000000000000
--- a/spaces/Reha2704/VToonify/vtoonify/smooth_parsing_map.py
+++ /dev/null
@@ -1,172 +0,0 @@
-import os
-#os.environ['CUDA_VISIBLE_DEVICES'] = "0"
-import numpy as np
-import cv2
-import math
-import argparse
-from tqdm import tqdm
-import torch
-from torch import nn
-from torchvision import transforms
-import torch.nn.functional as F
-from model.raft.core.raft import RAFT
-from model.raft.core.utils.utils import InputPadder
-from model.bisenet.model import BiSeNet
-from model.stylegan.model import Downsample
-
-class Options():
-    def __init__(self):
-
-        self.parser = argparse.ArgumentParser(description="Smooth Parsing Maps")
-        self.parser.add_argument("--window_size", type=int, default=5, help="temporal window size")
-        
-        self.parser.add_argument("--faceparsing_path", type=str, default='./checkpoint/faceparsing.pth', help="path of the face parsing model")
-        self.parser.add_argument("--raft_path", type=str, default='./checkpoint/raft-things.pth', help="path of the RAFT model")
-        
-        self.parser.add_argument("--video_path", type=str, help="path of the target video")
-        self.parser.add_argument("--output_path", type=str, default='./output/', help="path of the output parsing maps")
-        
-    def parse(self):
-        self.opt = self.parser.parse_args()
-        args = vars(self.opt)
-        print('Load options')
-        for name, value in sorted(args.items()):
-            print('%s: %s' % (str(name), str(value)))
-        return self.opt                
-
-# from RAFT
-def warp(x, flo):
-    """
-    warp an image/tensor (im2) back to im1, according to the optical flow
-    x: [B, C, H, W] (im2)
-    flo: [B, 2, H, W] flow
-    """
-    B, C, H, W = x.size()
-    # mesh grid 
-    xx = torch.arange(0, W).view(1,-1).repeat(H,1)
-    yy = torch.arange(0, H).view(-1,1).repeat(1,W)
-    xx = xx.view(1,1,H,W).repeat(B,1,1,1)
-    yy = yy.view(1,1,H,W).repeat(B,1,1,1)
-    grid = torch.cat((xx,yy),1).float()
-
-
-    #x = x.cuda()
-    grid = grid.cuda()
-    vgrid = grid + flo # B,2,H,W
-
-    # scale grid to [-1,1] 
-    ##2019 code
-    vgrid[:,0,:,:] = 2.0*vgrid[:,0,:,:].clone()/max(W-1,1)-1.0 
-    vgrid[:,1,:,:] = 2.0*vgrid[:,1,:,:].clone()/max(H-1,1)-1.0
-
-    vgrid = vgrid.permute(0,2,3,1)
-    output = nn.functional.grid_sample(x, vgrid,align_corners=True)
-    mask = torch.autograd.Variable(torch.ones(x.size())).cuda()
-    mask = nn.functional.grid_sample(mask, vgrid,align_corners=True)
-
-    ##2019 author
-    mask[mask<0.9999] = 0
-    mask[mask>0] = 1
-
-     ##2019 code
-     # mask = torch.floor(torch.clamp(mask, 0 ,1))
-
-    return output*mask, mask
-
-    
-if __name__ == "__main__":
-
-    parser = Options()
-    args = parser.parse()
-    print('*'*98)
-    
-    
-    device = "cuda"
-    
-    transform = transforms.Compose([
-    transforms.ToTensor(),
-    transforms.Normalize(mean=[0.5, 0.5, 0.5],std=[0.5,0.5,0.5]),
-    ])
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--model', help="restore checkpoint")
-    parser.add_argument('--small', action='store_true', help='use small model')
-    parser.add_argument('--mixed_precision', action='store_true', help='use mixed precision')
-    parser.add_argument('--alternate_corr', action='store_true', help='use efficent correlation implementation')
-
-    raft_model = torch.nn.DataParallel(RAFT(parser.parse_args(['--model', args.raft_path])))
-    raft_model.load_state_dict(torch.load(args.raft_path))
-
-    raft_model = raft_model.module
-    raft_model.to(device)
-    raft_model.eval()
-
-    parsingpredictor = BiSeNet(n_classes=19)
-    parsingpredictor.load_state_dict(torch.load(args.faceparsing_path, map_location=lambda storage, loc: storage))
-    parsingpredictor.to(device).eval()
-
-    down = Downsample(kernel=[1, 3, 3, 1], factor=2).to(device).eval()
-
-    print('Load models successfully!')
-    
-    window = args.window_size
-
-    video_cap = cv2.VideoCapture(args.video_path)
-    num = int(video_cap.get(7))
-
-    Is = []
-    for i in range(num):
-        success, frame = video_cap.read()
-        if success == False:
-            break
-        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        with torch.no_grad():
-            Is += [transform(frame).unsqueeze(dim=0).cpu()]
-    video_cap.release()      
-
-    # enlarge frames for more accurate parsing maps and optical flows     
-    Is = F.upsample(torch.cat(Is, dim=0), scale_factor=2, mode='bilinear')
-    Is_ = torch.cat((Is[0:window], Is, Is[-window:]), dim=0)
-
-    print('Load video with %d frames successfully!'%(len(Is)))
-
-    Ps = []
-    for i in tqdm(range(len(Is))):
-        with torch.no_grad():
-            Ps += [parsingpredictor(2*Is[i:i+1].to(device))[0].detach().cpu()]
-    Ps = torch.cat(Ps, dim=0)
-    Ps_ = torch.cat((Ps[0:window], Ps, Ps[-window:]), dim=0)
-
-    print('Predict parsing maps successfully!')
-    
-    
-    # temporal weights of the (2*args.window_size+1) frames
-    wt = torch.exp(-(torch.arange(2*window+1).float()-window)**2/(2*((window+0.5)**2))).reshape(2*window+1,1,1,1).to(device)
-    
-    parse = []
-    for ii in tqdm(range(len(Is))):
-        i = ii + window
-        image2 = Is_[i-window:i+window+1].to(device)
-        image1 = Is_[i].repeat(2*window+1,1,1,1).to(device)
-        padder = InputPadder(image1.shape)
-        image1, image2 = padder.pad(image1, image2)
-        with torch.no_grad():
-            flow_low, flow_up = raft_model((image1+1)*255.0/2, (image2+1)*255.0/2, iters=20, test_mode=True)
-            output, mask = warp(torch.cat((image2, Ps_[i-window:i+window+1].to(device)), dim=1), flow_up)
-            aligned_Is = output[:,0:3].detach()
-            aligned_Ps = output[:,3:].detach()
-            # the spatial weight
-            ws = torch.exp(-((aligned_Is-image1)**2).mean(dim=1, keepdims=True)/(2*(0.2**2))) * mask[:,0:1]
-            aligned_Ps[window] = Ps_[i].to(device)
-            # the weight between i and i shoud be 1.0
-            ws[window,:,:,:] = 1.0
-            weights = ws*wt
-            weights = weights / weights.sum(dim=(0), keepdims=True)
-            fused_Ps = (aligned_Ps * weights).sum(dim=0, keepdims=True)
-            parse += [down(fused_Ps).detach().cpu()]
-    parse = torch.cat(parse, dim=0)
-    
-    basename = os.path.basename(args.video_path).split('.')[0]
-    np.save(os.path.join(args.output_path, basename+'_parsingmap.npy'), parse.numpy())
-    
-    print('Done!')
\ No newline at end of file
diff --git a/spaces/Ritori/TTS_Yui/hifi-gan/denoiser.py b/spaces/Ritori/TTS_Yui/hifi-gan/denoiser.py
deleted file mode 100644
index 24f38573c571aeb0e12f72270ad17b2f0ada362a..0000000000000000000000000000000000000000
--- a/spaces/Ritori/TTS_Yui/hifi-gan/denoiser.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import sys
-import torch
-from stft import STFT
-
-
-class Denoiser(torch.nn.Module):
-    """ WaveGlow denoiser, adapted for HiFi-GAN """
-
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-
-    def __init__(
-        self, hifigan, filter_length=1024, n_overlap=4, win_length=1024, mode="zeros"
-    ):
-        super(Denoiser, self).__init__()
-        self.stft = STFT(
-            filter_length=filter_length,
-            hop_length=int(filter_length / n_overlap),
-            win_length=win_length,
-        ).to(Denoiser.device)
-        if mode == "zeros":
-            mel_input = torch.zeros((1, 80, 88)).to(Denoiser.device)
-        elif mode == "normal":
-            mel_input = torch.randn((1, 80, 88)).to(Denoiser.device)
-        else:
-            raise Exception("Mode {} if not supported".format(mode))
-
-        with torch.no_grad():
-            bias_audio = hifigan(mel_input).view(1, -1).float()
-            bias_spec, _ = self.stft.transform(bias_audio)
-
-        self.register_buffer("bias_spec", bias_spec[:, :, 0][:, :, None])
-
-    def forward(self, audio, strength=0.1):
-        audio_spec, audio_angles = self.stft.transform(audio.to(Denoiser.device).float())
-        audio_spec_denoised = audio_spec - self.bias_spec * strength
-        audio_spec_denoised = torch.clamp(audio_spec_denoised, 0.0)
-        audio_denoised = self.stft.inverse(audio_spec_denoised, audio_angles)
-        return audio_denoised
diff --git a/spaces/Ritori/play_with_baby_llama2/baby_llama2.py b/spaces/Ritori/play_with_baby_llama2/baby_llama2.py
deleted file mode 100644
index 7f89f18bc45b563439e92835b7f17eee13d1968b..0000000000000000000000000000000000000000
--- a/spaces/Ritori/play_with_baby_llama2/baby_llama2.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import os
-import subprocess
-import gradio as gr
-from translate import Translator
-
-def compile_c_program():
-    compile_command = ["gcc", "-o", "run", "run.c"]  # replace "source.c" with your C source file
-    subprocess.check_call(compile_command)  # this will raise an error if compilation fails
-
-def generate_text():
-    # Make sure the C program is compiled before we try to run it
-    if not os.path.exists("run"):
-        compile_c_program()
-    os.chmod('run', 0o755)
-    cmd = ['./run', 'model.bin']
-    result = subprocess.run(cmd, stdout=subprocess.PIPE, text=True)
-    translator= Translator(from_lang='en', to_lang='zh-cn')
-    
-    # Split the output into sentences
-    sentences = result.stdout.split('. ')
-    
-    # Translate each sentence and join them back together
-    translation = '. '.join(translator.translate(sentence) for sentence in sentences)
-    
-    return result
-
-iface = gr.Interface(
-    fn=generate_text, 
-    inputs=[], 
-    outputs="text", 
-    submit_label="开始生成", 
-    title="和小羊驼一起玩"
-)
-iface.launch(debug=True)
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmseg/models/decode_heads/da_head.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmseg/models/decode_heads/da_head.py
deleted file mode 100644
index 5cd49fcfdc7c0a70f9485cc71843dcf3e0cb1774..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmseg/models/decode_heads/da_head.py
+++ /dev/null
@@ -1,178 +0,0 @@
-import torch
-import torch.nn.functional as F
-from annotator.uniformer.mmcv.cnn import ConvModule, Scale
-from torch import nn
-
-from annotator.uniformer.mmseg.core import add_prefix
-from ..builder import HEADS
-from ..utils import SelfAttentionBlock as _SelfAttentionBlock
-from .decode_head import BaseDecodeHead
-
-
-class PAM(_SelfAttentionBlock):
-    """Position Attention Module (PAM)
-
-    Args:
-        in_channels (int): Input channels of key/query feature.
-        channels (int): Output channels of key/query transform.
-    """
-
-    def __init__(self, in_channels, channels):
-        super(PAM, self).__init__(
-            key_in_channels=in_channels,
-            query_in_channels=in_channels,
-            channels=channels,
-            out_channels=in_channels,
-            share_key_query=False,
-            query_downsample=None,
-            key_downsample=None,
-            key_query_num_convs=1,
-            key_query_norm=False,
-            value_out_num_convs=1,
-            value_out_norm=False,
-            matmul_norm=False,
-            with_out=False,
-            conv_cfg=None,
-            norm_cfg=None,
-            act_cfg=None)
-
-        self.gamma = Scale(0)
-
-    def forward(self, x):
-        """Forward function."""
-        out = super(PAM, self).forward(x, x)
-
-        out = self.gamma(out) + x
-        return out
-
-
-class CAM(nn.Module):
-    """Channel Attention Module (CAM)"""
-
-    def __init__(self):
-        super(CAM, self).__init__()
-        self.gamma = Scale(0)
-
-    def forward(self, x):
-        """Forward function."""
-        batch_size, channels, height, width = x.size()
-        proj_query = x.view(batch_size, channels, -1)
-        proj_key = x.view(batch_size, channels, -1).permute(0, 2, 1)
-        energy = torch.bmm(proj_query, proj_key)
-        energy_new = torch.max(
-            energy, -1, keepdim=True)[0].expand_as(energy) - energy
-        attention = F.softmax(energy_new, dim=-1)
-        proj_value = x.view(batch_size, channels, -1)
-
-        out = torch.bmm(attention, proj_value)
-        out = out.view(batch_size, channels, height, width)
-
-        out = self.gamma(out) + x
-        return out
-
-
-@HEADS.register_module()
-class DAHead(BaseDecodeHead):
-    """Dual Attention Network for Scene Segmentation.
-
-    This head is the implementation of `DANet
-    <https://arxiv.org/abs/1809.02983>`_.
-
-    Args:
-        pam_channels (int): The channels of Position Attention Module(PAM).
-    """
-
-    def __init__(self, pam_channels, **kwargs):
-        super(DAHead, self).__init__(**kwargs)
-        self.pam_channels = pam_channels
-        self.pam_in_conv = ConvModule(
-            self.in_channels,
-            self.channels,
-            3,
-            padding=1,
-            conv_cfg=self.conv_cfg,
-            norm_cfg=self.norm_cfg,
-            act_cfg=self.act_cfg)
-        self.pam = PAM(self.channels, pam_channels)
-        self.pam_out_conv = ConvModule(
-            self.channels,
-            self.channels,
-            3,
-            padding=1,
-            conv_cfg=self.conv_cfg,
-            norm_cfg=self.norm_cfg,
-            act_cfg=self.act_cfg)
-        self.pam_conv_seg = nn.Conv2d(
-            self.channels, self.num_classes, kernel_size=1)
-
-        self.cam_in_conv = ConvModule(
-            self.in_channels,
-            self.channels,
-            3,
-            padding=1,
-            conv_cfg=self.conv_cfg,
-            norm_cfg=self.norm_cfg,
-            act_cfg=self.act_cfg)
-        self.cam = CAM()
-        self.cam_out_conv = ConvModule(
-            self.channels,
-            self.channels,
-            3,
-            padding=1,
-            conv_cfg=self.conv_cfg,
-            norm_cfg=self.norm_cfg,
-            act_cfg=self.act_cfg)
-        self.cam_conv_seg = nn.Conv2d(
-            self.channels, self.num_classes, kernel_size=1)
-
-    def pam_cls_seg(self, feat):
-        """PAM feature classification."""
-        if self.dropout is not None:
-            feat = self.dropout(feat)
-        output = self.pam_conv_seg(feat)
-        return output
-
-    def cam_cls_seg(self, feat):
-        """CAM feature classification."""
-        if self.dropout is not None:
-            feat = self.dropout(feat)
-        output = self.cam_conv_seg(feat)
-        return output
-
-    def forward(self, inputs):
-        """Forward function."""
-        x = self._transform_inputs(inputs)
-        pam_feat = self.pam_in_conv(x)
-        pam_feat = self.pam(pam_feat)
-        pam_feat = self.pam_out_conv(pam_feat)
-        pam_out = self.pam_cls_seg(pam_feat)
-
-        cam_feat = self.cam_in_conv(x)
-        cam_feat = self.cam(cam_feat)
-        cam_feat = self.cam_out_conv(cam_feat)
-        cam_out = self.cam_cls_seg(cam_feat)
-
-        feat_sum = pam_feat + cam_feat
-        pam_cam_out = self.cls_seg(feat_sum)
-
-        return pam_cam_out, pam_out, cam_out
-
-    def forward_test(self, inputs, img_metas, test_cfg):
-        """Forward function for testing, only ``pam_cam`` is used."""
-        return self.forward(inputs)[0]
-
-    def losses(self, seg_logit, seg_label):
-        """Compute ``pam_cam``, ``pam``, ``cam`` loss."""
-        pam_cam_seg_logit, pam_seg_logit, cam_seg_logit = seg_logit
-        loss = dict()
-        loss.update(
-            add_prefix(
-                super(DAHead, self).losses(pam_cam_seg_logit, seg_label),
-                'pam_cam'))
-        loss.update(
-            add_prefix(
-                super(DAHead, self).losses(pam_seg_logit, seg_label), 'pam'))
-        loss.update(
-            add_prefix(
-                super(DAHead, self).losses(cam_seg_logit, seg_label), 'cam'))
-        return loss
diff --git a/spaces/SIGGRAPH2022/Text2Human/Text2Human/models/losses/vqgan_loss.py b/spaces/SIGGRAPH2022/Text2Human/Text2Human/models/losses/vqgan_loss.py
deleted file mode 100644
index f07315711e2fabae548a2dc48743f593be6f8e39..0000000000000000000000000000000000000000
--- a/spaces/SIGGRAPH2022/Text2Human/Text2Human/models/losses/vqgan_loss.py
+++ /dev/null
@@ -1,114 +0,0 @@
-import torch
-import torch.nn.functional as F
-
-
-def calculate_adaptive_weight(recon_loss, g_loss, last_layer, disc_weight_max):
-    recon_grads = torch.autograd.grad(
-        recon_loss, last_layer, retain_graph=True)[0]
-    g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0]
-
-    d_weight = torch.norm(recon_grads) / (torch.norm(g_grads) + 1e-4)
-    d_weight = torch.clamp(d_weight, 0.0, disc_weight_max).detach()
-    return d_weight
-
-
-def adopt_weight(weight, global_step, threshold=0, value=0.):
-    if global_step < threshold:
-        weight = value
-    return weight
-
-
-@torch.jit.script
-def hinge_d_loss(logits_real, logits_fake):
-    loss_real = torch.mean(F.relu(1. - logits_real))
-    loss_fake = torch.mean(F.relu(1. + logits_fake))
-    d_loss = 0.5 * (loss_real + loss_fake)
-    return d_loss
-
-
-def DiffAugment(x, policy='', channels_first=True):
-    if policy:
-        if not channels_first:
-            x = x.permute(0, 3, 1, 2)
-        for p in policy.split(','):
-            for f in AUGMENT_FNS[p]:
-                x = f(x)
-        if not channels_first:
-            x = x.permute(0, 2, 3, 1)
-        x = x.contiguous()
-    return x
-
-
-def rand_brightness(x):
-    x = x + (
-        torch.rand(x.size(0), 1, 1, 1, dtype=x.dtype, device=x.device) - 0.5)
-    return x
-
-
-def rand_saturation(x):
-    x_mean = x.mean(dim=1, keepdim=True)
-    x = (x - x_mean) * (torch.rand(
-        x.size(0), 1, 1, 1, dtype=x.dtype, device=x.device) * 2) + x_mean
-    return x
-
-
-def rand_contrast(x):
-    x_mean = x.mean(dim=[1, 2, 3], keepdim=True)
-    x = (x - x_mean) * (torch.rand(
-        x.size(0), 1, 1, 1, dtype=x.dtype, device=x.device) + 0.5) + x_mean
-    return x
-
-
-def rand_translation(x, ratio=0.125):
-    shift_x, shift_y = int(x.size(2) * ratio +
-                           0.5), int(x.size(3) * ratio + 0.5)
-    translation_x = torch.randint(
-        -shift_x, shift_x + 1, size=[x.size(0), 1, 1], device=x.device)
-    translation_y = torch.randint(
-        -shift_y, shift_y + 1, size=[x.size(0), 1, 1], device=x.device)
-    grid_batch, grid_x, grid_y = torch.meshgrid(
-        torch.arange(x.size(0), dtype=torch.long, device=x.device),
-        torch.arange(x.size(2), dtype=torch.long, device=x.device),
-        torch.arange(x.size(3), dtype=torch.long, device=x.device),
-    )
-    grid_x = torch.clamp(grid_x + translation_x + 1, 0, x.size(2) + 1)
-    grid_y = torch.clamp(grid_y + translation_y + 1, 0, x.size(3) + 1)
-    x_pad = F.pad(x, [1, 1, 1, 1, 0, 0, 0, 0])
-    x = x_pad.permute(0, 2, 3, 1).contiguous()[grid_batch, grid_x,
-                                               grid_y].permute(0, 3, 1, 2)
-    return x
-
-
-def rand_cutout(x, ratio=0.5):
-    cutout_size = int(x.size(2) * ratio + 0.5), int(x.size(3) * ratio + 0.5)
-    offset_x = torch.randint(
-        0,
-        x.size(2) + (1 - cutout_size[0] % 2),
-        size=[x.size(0), 1, 1],
-        device=x.device)
-    offset_y = torch.randint(
-        0,
-        x.size(3) + (1 - cutout_size[1] % 2),
-        size=[x.size(0), 1, 1],
-        device=x.device)
-    grid_batch, grid_x, grid_y = torch.meshgrid(
-        torch.arange(x.size(0), dtype=torch.long, device=x.device),
-        torch.arange(cutout_size[0], dtype=torch.long, device=x.device),
-        torch.arange(cutout_size[1], dtype=torch.long, device=x.device),
-    )
-    grid_x = torch.clamp(
-        grid_x + offset_x - cutout_size[0] // 2, min=0, max=x.size(2) - 1)
-    grid_y = torch.clamp(
-        grid_y + offset_y - cutout_size[1] // 2, min=0, max=x.size(3) - 1)
-    mask = torch.ones(
-        x.size(0), x.size(2), x.size(3), dtype=x.dtype, device=x.device)
-    mask[grid_batch, grid_x, grid_y] = 0
-    x = x * mask.unsqueeze(1)
-    return x
-
-
-AUGMENT_FNS = {
-    'color': [rand_brightness, rand_saturation, rand_contrast],
-    'translation': [rand_translation],
-    'cutout': [rand_cutout],
-}
diff --git a/spaces/Sapphire-356/Video2MC/joints_detectors/Alphapose/SPPE/src/utils/dataset/coco.py b/spaces/Sapphire-356/Video2MC/joints_detectors/Alphapose/SPPE/src/utils/dataset/coco.py
deleted file mode 100644
index e1f264648b5bac3090d75021b8245251b866b519..0000000000000000000000000000000000000000
--- a/spaces/Sapphire-356/Video2MC/joints_detectors/Alphapose/SPPE/src/utils/dataset/coco.py
+++ /dev/null
@@ -1,85 +0,0 @@
-import os
-import h5py
-from functools import reduce
-
-import torch.utils.data as data
-from ..pose import generateSampleBox
-from opt import opt
-
-
-class Mscoco(data.Dataset):
-    def __init__(self, train=True, sigma=1,
-                 scale_factor=(0.2, 0.3), rot_factor=40, label_type='Gaussian'):
-        self.img_folder = '../data/coco/images'    # root image folders
-        self.is_train = train           # training set or test set
-        self.inputResH = opt.inputResH
-        self.inputResW = opt.inputResW
-        self.outputResH = opt.outputResH
-        self.outputResW = opt.outputResW
-        self.sigma = sigma
-        self.scale_factor = scale_factor
-        self.rot_factor = rot_factor
-        self.label_type = label_type
-
-        self.nJoints_coco = 17
-        self.nJoints_mpii = 16
-        self.nJoints = 33
-
-        self.accIdxs = (1, 2, 3, 4, 5, 6, 7, 8,
-                        9, 10, 11, 12, 13, 14, 15, 16, 17)
-        self.flipRef = ((2, 3), (4, 5), (6, 7),
-                        (8, 9), (10, 11), (12, 13),
-                        (14, 15), (16, 17))
-
-        # create train/val split
-        with h5py.File('../data/coco/annot_clean.h5', 'r') as annot:
-            # train
-            self.imgname_coco_train = annot['imgname'][:-5887]
-            self.bndbox_coco_train = annot['bndbox'][:-5887]
-            self.part_coco_train = annot['part'][:-5887]
-            # val
-            self.imgname_coco_val = annot['imgname'][-5887:]
-            self.bndbox_coco_val = annot['bndbox'][-5887:]
-            self.part_coco_val = annot['part'][-5887:]
-
-        self.size_train = self.imgname_coco_train.shape[0]
-        self.size_val = self.imgname_coco_val.shape[0]
-
-    def __getitem__(self, index):
-        sf = self.scale_factor
-
-        if self.is_train:
-            part = self.part_coco_train[index]
-            bndbox = self.bndbox_coco_train[index]
-            imgname = self.imgname_coco_train[index]
-        else:
-            part = self.part_coco_val[index]
-            bndbox = self.bndbox_coco_val[index]
-            imgname = self.imgname_coco_val[index]
-
-        imgname = reduce(lambda x, y: x + y, map(lambda x: chr(int(x)), imgname))
-        img_path = os.path.join(self.img_folder, imgname)
-
-        metaData = generateSampleBox(img_path, bndbox, part, self.nJoints,
-                                     'coco', sf, self, train=self.is_train)
-
-        inp, out_bigcircle, out_smallcircle, out, setMask = metaData
-
-        label = []
-        for i in range(opt.nStack):
-            if i < 2:
-                # label.append(out_bigcircle.clone())
-                label.append(out.clone())
-            elif i < 4:
-                # label.append(out_smallcircle.clone())
-                label.append(out.clone())
-            else:
-                label.append(out.clone())
-
-        return inp, label, setMask, 'coco'
-
-    def __len__(self):
-        if self.is_train:
-            return self.size_train
-        else:
-            return self.size_val
diff --git a/spaces/Shad0ws/ImageModelTestEnvironment/index.html b/spaces/Shad0ws/ImageModelTestEnvironment/index.html
deleted file mode 100644
index 6250c2958a7186a4e64f21c02b0359ff5ecd7e97..0000000000000000000000000000000000000000
--- a/spaces/Shad0ws/ImageModelTestEnvironment/index.html
+++ /dev/null
@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="twitter:card" content="player"/>
-    <meta name="twitter:site" content=""/>
-    <meta name="twitter:player" content="https://omnibus-maximum-multiplier-places.hf.space"/>
-    <meta name="twitter:player:stream" content="https://omnibus-maximum-multiplier-places.hf.space"/>
-    <meta name="twitter:player:width" content="100%"/>
-    <meta name="twitter:player:height" content="600"/>    
-    <meta property="og:title" content="Embedded Live Viewer"/>
-    <meta property="og:description" content="Tweet Genie - A Huggingface Space"/>
-    <meta property="og:image" content="https://cdn.glitch.global/80dbe92e-ce75-44af-84d5-74a2e21e9e55/omnicard.png?v=1676772531627"/>
-    <!--<meta http-equiv="refresh" content="0; url=https://huggingface.co/spaces/corbt/tweet-genie">-->
-  </head>
-</html>
\ No newline at end of file
diff --git a/spaces/Shawn37/UTR_LM/esm/data_supervised.py b/spaces/Shawn37/UTR_LM/esm/data_supervised.py
deleted file mode 100644
index 62789c0dc7ea5bfd52130eb724c090cc9837df93..0000000000000000000000000000000000000000
--- a/spaces/Shawn37/UTR_LM/esm/data_supervised.py
+++ /dev/null
@@ -1,524 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import itertools
-import os
-from typing import Sequence, Tuple, List, Union
-import pickle
-import re
-import shutil
-import torch
-from pathlib import Path
-from .constants import proteinseq_toks, rnaseq_toks
-import math
-import random
-from copy import deepcopy
-
-RawMSA = Sequence[Tuple[str, str]]
-
-
-class Alphabet(object):
-    def __init__(
-        self,
-        standard_toks: Sequence[str],
-        prepend_toks: Sequence[str] = ("<pad>", "<eos>", "<unk>"), # "<null_0>",
-        append_toks: Sequence[str] = ("<cls>", "<mask>", "<sep>"), # 
-        prepend_bos: bool = True,
-        append_eos: bool = True,
-        use_msa: bool = False,
-        mask_prob: float = 0.15, ###---
-    ):
-        self.mask_prob = mask_prob ###---
-        self.standard_toks = list(standard_toks)
-        self.prepend_toks = list(prepend_toks)
-        self.append_toks = list(append_toks)
-        self.prepend_bos = prepend_bos
-        self.append_eos = append_eos
-        self.use_msa = use_msa
-
-        self.all_toks = list(self.prepend_toks)
-        self.all_toks.extend(self.standard_toks)
-#         for i in range((8 - (len(self.all_toks) % 8)) % 8):
-#             self.all_toks.append(f"<null_{i  + 1}>")
-        self.all_toks.extend(self.append_toks)
-
-        self.tok_to_idx = {tok: i for i, tok in enumerate(self.all_toks)}
-#         print(self.tok_to_idx)
-        self.unk_idx = self.tok_to_idx["<unk>"]
-        self.padding_idx = self.get_idx("<pad>")
-        self.cls_idx = self.get_idx("<cls>")
-        self.mask_idx = self.get_idx("<mask>")
-        self.eos_idx = self.get_idx("<eos>")
-        self.all_special_tokens = ['<eos>', '<pad>', '<mask>'] # , '<unk>', '<cls>'
-        self.unique_no_split_tokens = self.all_toks
-
-    def __len__(self):
-        return len(self.all_toks)
-
-    def get_idx(self, tok):
-        return self.tok_to_idx.get(tok, self.unk_idx)
-
-    def get_tok(self, ind):
-        return self.all_toks[ind]
-
-    def to_dict(self):
-        return self.tok_to_idx.copy()
-
-    def get_batch_converter(self):
-        if self.use_msa:
-            return MSABatchConverter(self)
-        else:
-            return BatchConverter(self)
-
-    @classmethod
-    def from_architecture(cls, name: str) -> "Alphabet":
-        if name in ("ESM-1", "protein_bert_base"):
-            standard_toks = proteinseq_toks["toks"]
-            prepend_toks: Tuple[str, ...] = ("<null_0>", "<pad>", "<eos>", "<unk>")
-            append_toks: Tuple[str, ...] = ("<cls>", "<mask>", "<sep>")
-            prepend_bos = True
-            append_eos = False
-            use_msa = False
-        elif name in ("ESM-1b", "roberta_large"):
-            standard_toks = proteinseq_toks["toks"] ###---rnaseq
-            prepend_toks = ("<cls>", "<pad>", "<eos>", "<unk>")
-            append_toks = ("<mask>",)
-            prepend_bos = True
-            append_eos = True
-            use_msa = False
-        elif name in ("MSA Transformer", "msa_transformer"):
-            standard_toks = proteinseq_toks["toks"]
-            prepend_toks = ("<cls>", "<pad>", "<eos>", "<unk>")
-            append_toks = ("<mask>",)
-            prepend_bos = True
-            append_eos = False
-            use_msa = True
-        else:
-            raise ValueError("Unknown architecture selected")
-        return cls(standard_toks, prepend_toks, append_toks, prepend_bos, append_eos, use_msa)
-
-    def _tokenize(self, text) -> str:
-        return text.split()
-
-    def tokenize(self, text, **kwargs) -> List[str]:
-        """
-        Inspired by https://github.com/huggingface/transformers/blob/master/src/transformers/tokenization_utils.py
-        Converts a string in a sequence of tokens, using the tokenizer.
-
-        Args:
-            text (:obj:`str`):
-                The sequence to be encoded.
-
-        Returns:
-            :obj:`List[str]`: The list of tokens.
-        """
-
-        def split_on_token(tok, text):
-            result = []
-            split_text = text.split(tok)
-            for i, sub_text in enumerate(split_text):
-                # AddedToken can control whitespace stripping around them.
-                # We use them for GPT2 and Roberta to have different behavior depending on the special token
-                # Cf. https://github.com/huggingface/transformers/pull/2778
-                # and https://github.com/huggingface/transformers/issues/3788
-                # We strip left and right by default
-                if i < len(split_text) - 1:
-                    sub_text = sub_text.rstrip()
-                if i > 0:
-                    sub_text = sub_text.lstrip()
-
-                if i == 0 and not sub_text:
-                    result.append(tok)
-                elif i == len(split_text) - 1:
-                    if sub_text:
-                        result.append(sub_text)
-                    else:
-                        pass
-                else:
-                    if sub_text:
-                        result.append(sub_text)
-                    result.append(tok)
-            return result
-
-        def split_on_tokens(tok_list, text):
-            if not text.strip():
-                return []
-
-            tokenized_text = []
-            text_list = [text]
-            for tok in tok_list:
-                tokenized_text = []
-                for sub_text in text_list:
-                    if sub_text not in self.unique_no_split_tokens:
-                        tokenized_text.extend(split_on_token(tok, sub_text))
-                    else:
-                        tokenized_text.append(sub_text)
-                text_list = tokenized_text
-
-            return list(
-                itertools.chain.from_iterable(
-                    (
-                        self._tokenize(token)
-                        if token not in self.unique_no_split_tokens
-                        else [token]
-                        for token in tokenized_text
-                    )
-                )
-            )
-
-        no_split_token = self.unique_no_split_tokens
-        tokenized_text = split_on_tokens(no_split_token, text)
-        return tokenized_text
-
-    def encode(self, text):
-        return [self.tok_to_idx[tok] for tok in self.tokenize(text)]
-
-class FastaBatchedDataset(object):
-    def __init__(self, sequence_labels, sequence_strs, mask_prob = 0.15):
-        self.sequence_labels = list(sequence_labels)
-        self.sequence_strs = list(sequence_strs)
-        self.mask_prob = mask_prob
-        
-    @classmethod
-    def from_file(cls, fasta_file, mask_prob = 0.15):
-        sequence_labels, sequence_strs = [], []
-        cur_seq_label = None
-        buf = []
-
-        def _flush_current_seq():
-            nonlocal cur_seq_label, buf
-            if cur_seq_label is None:
-                return
-            sequence_labels.append(cur_seq_label)
-            sequence_strs.append("".join(buf))
-            cur_seq_label = None
-            buf = []
-
-        with open(fasta_file, "r") as infile:
-            for line_idx, line in enumerate(infile):
-                if line.startswith(">"):  # label line
-                    _flush_current_seq()
-                    line = line[1:].strip()
-                    if len(line) > 0:
-                        cur_seq_label = line
-                    else:
-                        cur_seq_label = f"seqnum{line_idx:09d}"
-                else:  # sequence line
-                    buf.append(line.strip())
-
-        _flush_current_seq()
-
-        assert len(set(sequence_labels)) == len(
-            sequence_labels
-        ), "Found duplicate sequence labels"
-
-        return cls(sequence_labels, sequence_strs, mask_prob)
-
-    def __len__(self):
-        return len(self.sequence_labels)
-    
-    def mask_sequence(self, seq): ###---
-        length = len(seq)
-#         print(self.mask_prob)
-        max_length = math.ceil(length * self.mask_prob)
-        rand = random.sample(range(0, length), max_length)
-        res = ''.join(['<mask>' if idx in rand else ele for idx, ele in enumerate(seq)])
-        #print(seq, rand, res)
-        return rand, res
-    
-    def __getitem__(self, idx):
-        sequence_str = self.sequence_strs[idx]
-        sequence_label = self.sequence_labels[idx]
-        masked_indices, masked_sequence_str = self.mask_sequence(sequence_str)
-        return sequence_label, sequence_str, masked_sequence_str, masked_indices
-
-    def get_batch_indices(self, toks_per_batch, extra_toks_per_seq=0):
-        sizes = [(len(s), i) for i, s in enumerate(self.sequence_strs)]
-        sizes.sort()
-        batches = []
-        buf = []
-        max_len = 0
-
-        def _flush_current_buf():
-            nonlocal max_len, buf
-            if len(buf) == 0:
-                return
-            batches.append(buf)
-            buf = []
-            max_len = 0
-
-        for sz, i in sizes:
-            sz += extra_toks_per_seq
-            if max(sz, max_len) * (len(buf) + 1) > toks_per_batch:
-                _flush_current_buf()
-            max_len = max(max_len, sz)
-            buf.append(i)
-
-        _flush_current_buf()
-        return batches
-
-class BatchConverter(object):
-    """Callable to convert an unprocessed (labels + strings) batch to a
-    processed (labels + tensor) batch.
-    """
-
-    def __init__(self, alphabet):
-        self.alphabet = alphabet
-
-    def __call__(self, raw_batch: Sequence[Tuple[str, str]]): 
-        # RoBERTa uses an eos token, while ESM-1 does not.
-        batch_size = len(raw_batch)
-        batch_labels, seq_str_list, masked_seq_str_list, masked_indices_list = zip(*raw_batch)
-        
-        masked_seq_encoded_list = [self.alphabet.encode(seq_str) for seq_str in masked_seq_str_list] ###---
-        seq_encoded_list = [self.alphabet.encode(seq_str) for seq_str in seq_str_list] ###---
-#         print('====', seq_str_list)
-#         print('----', masked_seq_str_list)
-#         print('++++', masked_seq_encoded_list)
-#         print('****', seq_encoded_list)
-        
-        max_len = max(len(seq_encoded) for seq_encoded in masked_seq_encoded_list)
-        tokens = torch.empty(
-            (
-                batch_size,
-                max_len + int(self.alphabet.prepend_bos) + int(self.alphabet.append_eos),
-            ),
-            dtype=torch.int64,
-        )
-        tokens.fill_(self.alphabet.padding_idx)
-        masked_tokens = deepcopy(tokens)
-        
-        labels = []
-        strs, masked_strs = [], []
-        masked_indices = []
-#         print('=================')
-        for i, (label, seq_str, masked_seq_str, seq_encoded, masked_seq_encoded, indices_mask) in enumerate(
-            zip(batch_labels, seq_str_list, masked_seq_str_list, seq_encoded_list, masked_seq_encoded_list, masked_indices_list) ###---
-        ):
-            labels.append(label)
-            strs.append(seq_str)
-            masked_strs.append(masked_seq_str)
-            masked_indices.append(indices_mask)
-            
-            if self.alphabet.prepend_bos:
-                tokens[i, 0] = self.alphabet.cls_idx
-                masked_tokens[i, 0] = self.alphabet.cls_idx
-                
-            seq = torch.tensor(seq_encoded, dtype=torch.int64)
-            masked_seq = torch.tensor(masked_seq_encoded, dtype=torch.int64)
-#             print(tokens, masked_tokens)
-            tokens[
-                i,
-                int(self.alphabet.prepend_bos) : len(seq_encoded)
-                + int(self.alphabet.prepend_bos),
-            ] = seq
-            
-            masked_tokens[
-                i,
-                int(self.alphabet.prepend_bos) : len(masked_seq_encoded)
-                + int(self.alphabet.prepend_bos),
-            ] = masked_seq
-#             print(tokens, masked_tokens)
-            if self.alphabet.append_eos:
-                tokens[i, len(seq_encoded) + int(self.alphabet.prepend_bos)] = self.alphabet.eos_idx
-                masked_tokens[i, len(masked_seq_encoded) + int(self.alphabet.prepend_bos)] = self.alphabet.eos_idx
-#             print(tokens, masked_tokens)
-        return labels, strs, masked_strs, tokens, masked_tokens, masked_indices
-
-
-class MSABatchConverter(BatchConverter):
-    def __call__(self, inputs: Union[Sequence[RawMSA], RawMSA]):
-        if isinstance(inputs[0][0], str):
-            # Input is a single MSA
-            raw_batch: Sequence[RawMSA] = [inputs]  # type: ignore
-        else:
-            raw_batch = inputs  # type: ignore
-
-        batch_size = len(raw_batch)
-        max_alignments = max(len(msa) for msa in raw_batch)
-        max_seqlen = max(len(msa[0][1]) for msa in raw_batch)
-
-        tokens = torch.empty(
-            (
-                batch_size,
-                max_alignments,
-                max_seqlen + int(self.alphabet.prepend_bos) + int(self.alphabet.append_eos),
-            ),
-            dtype=torch.int64,
-        )
-        tokens.fill_(self.alphabet.padding_idx)
-        labels = []
-        strs = []
-
-        for i, msa in enumerate(raw_batch):
-            msa_seqlens = set(len(seq) for _, seq in msa)
-            if not len(msa_seqlens) == 1:
-                raise RuntimeError(
-                    "Received unaligned sequences for input to MSA, all sequence "
-                    "lengths must be equal."
-                )
-            msa_labels, msa_strs, msa_tokens = super().__call__(msa)
-            labels.append(msa_labels)
-            strs.append(msa_strs)
-            tokens[i, : msa_tokens.size(0), : msa_tokens.size(1)] = msa_tokens
-
-        return labels, strs, tokens
-
-
-def read_fasta(
-    path,
-    keep_gaps=True,
-    keep_insertions=True,
-    to_upper=False,
-):
-    with open(path, "r") as f:
-        for result in read_alignment_lines(
-            f, keep_gaps=keep_gaps, keep_insertions=keep_insertions, to_upper=to_upper
-        ):
-            yield result
-
-
-def read_alignment_lines(
-    lines,
-    keep_gaps=True,
-    keep_insertions=True,
-    to_upper=False,
-):
-    seq = desc = None
-
-    def parse(s):
-        if not keep_gaps:
-            s = re.sub("-", "", s)
-        if not keep_insertions:
-            s = re.sub("[a-z]", "", s)
-        return s.upper() if to_upper else s
-
-    for line in lines:
-        # Line may be empty if seq % file_line_width == 0
-        if len(line) > 0 and line[0] == ">":
-            if seq is not None:
-                yield desc, parse(seq)
-            desc = line.strip()
-            seq = ""
-        else:
-            assert isinstance(seq, str)
-            seq += line.strip()
-    assert isinstance(seq, str) and isinstance(desc, str)
-    yield desc, parse(seq)
-
-
-class ESMStructuralSplitDataset(torch.utils.data.Dataset):
-    """
-    Structural Split Dataset as described in section A.10 of the supplement of our paper.
-    https://doi.org/10.1101/622803
-
-    We use the full version of SCOPe 2.07, clustered at 90% sequence identity,
-    generated on January 23, 2020.
-
-    For each SCOPe domain:
-        - We extract the sequence from the corresponding PDB file
-        - We extract the 3D coordinates of the Carbon beta atoms, aligning them
-          to the sequence. We put NaN where Cb atoms are missing.
-        - From the 3D coordinates, we calculate a pairwise distance map, based
-          on L2 distance
-        - We use DSSP to generate secondary structure labels for the corresponding
-          PDB file. This is also aligned to the sequence. We put - where SSP
-          labels are missing.
-
-    For each SCOPe classification level of family/superfamily/fold (in order of difficulty),
-    we have split the data into 5 partitions for cross validation. These are provided
-    in a downloaded splits folder, in the format:
-            splits/{split_level}/{cv_partition}/{train|valid}.txt
-    where train is the partition and valid is the concatentation of the remaining 4.
-
-    For each SCOPe domain, we provide a pkl dump that contains:
-        - seq    : The domain sequence, stored as an L-length string
-        - ssp    : The secondary structure labels, stored as an L-length string
-        - dist   : The distance map, stored as an LxL numpy array
-        - coords : The 3D coordinates, stored as an Lx3 numpy array
-
-    """
-
-    base_folder = "structural-data"
-    file_list = [
-        #  url  tar filename   filename      MD5 Hash
-        (
-            "https://dl.fbaipublicfiles.com/fair-esm/structural-data/splits.tar.gz",
-            "splits.tar.gz",
-            "splits",
-            "456fe1c7f22c9d3d8dfe9735da52411d",
-        ),
-        (
-            "https://dl.fbaipublicfiles.com/fair-esm/structural-data/pkl.tar.gz",
-            "pkl.tar.gz",
-            "pkl",
-            "644ea91e56066c750cd50101d390f5db",
-        ),
-    ]
-
-    def __init__(
-        self,
-        split_level,
-        cv_partition,
-        split,
-        root_path=os.path.expanduser("~/.cache/torch/data/esm"),
-        download=False,
-    ):
-        super().__init__()
-        assert split in [
-            "train",
-            "valid",
-        ], "train_valid must be 'train' or 'valid'"
-        self.root_path = root_path
-        self.base_path = os.path.join(self.root_path, self.base_folder)
-
-        # check if root path has what you need or else download it
-        if download:
-            self.download()
-
-        self.split_file = os.path.join(
-            self.base_path, "splits", split_level, cv_partition, f"{split}.txt"
-        )
-        self.pkl_dir = os.path.join(self.base_path, "pkl")
-        self.names = []
-        with open(self.split_file) as f:
-            self.names = f.read().splitlines()
-
-    def __len__(self):
-        return len(self.names)
-
-    def _check_exists(self) -> bool:
-        for (_, _, filename, _) in self.file_list:
-            fpath = os.path.join(self.base_path, filename)
-            if not os.path.exists(fpath) or not os.path.isdir(fpath):
-                return False
-        return True
-
-    def download(self):
-
-        if self._check_exists():
-            print("Files already downloaded and verified")
-            return
-
-        from torchvision.datasets.utils import download_url
-
-        for url, tar_filename, filename, md5_hash in self.file_list:
-            download_path = os.path.join(self.base_path, tar_filename)
-            download_url(url=url, root=self.base_path, filename=tar_filename, md5=md5_hash)
-            shutil.unpack_archive(download_path, self.base_path)
-
-    def __getitem__(self, idx):
-        """
-        Returns a dict with the following entires
-         - seq : Str (domain sequence)
-         - ssp : Str (SSP labels)
-         - dist : np.array (distance map)
-         - coords : np.array (3D coordinates)
-        """
-        name = self.names[idx]
-        pkl_fname = os.path.join(self.pkl_dir, name[1:3], f"{name}.pkl")
-        with open(pkl_fname, "rb") as f:
-            obj = pickle.load(f)
-        return obj
diff --git a/spaces/Sreekumar1608/langchain-chat-with-pdf-openai/app.py b/spaces/Sreekumar1608/langchain-chat-with-pdf-openai/app.py
deleted file mode 100644
index cd31f3af4e476e89ead07fb4c0be53f9f4517f90..0000000000000000000000000000000000000000
--- a/spaces/Sreekumar1608/langchain-chat-with-pdf-openai/app.py
+++ /dev/null
@@ -1,106 +0,0 @@
-import gradio as gr
-import os
-import time
-
-from langchain.document_loaders import OnlinePDFLoader
-
-from langchain.text_splitter import CharacterTextSplitter
-
-
-from langchain.llms import OpenAI
-
-from langchain.embeddings import OpenAIEmbeddings
-
-
-from langchain.vectorstores import Chroma
-
-from langchain.chains import ConversationalRetrievalChain
-
-def loading_pdf():
-    return "Loading..."
-
-def pdf_changes(pdf_doc, open_ai_key):
-    if openai_key is not None:
-        os.environ['OPENAI_API_KEY'] = open_ai_key
-        loader = OnlinePDFLoader(pdf_doc.name)
-        documents = loader.load()
-        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
-        texts = text_splitter.split_documents(documents)
-        embeddings = OpenAIEmbeddings()
-        db = Chroma.from_documents(texts, embeddings)
-        retriever = db.as_retriever()
-        global qa 
-        qa = ConversationalRetrievalChain.from_llm(
-            llm=OpenAI(temperature=0.5), 
-            retriever=retriever, 
-            return_source_documents=False) # if you set this to True, you will not get a response due to a silent error.
-        return "Ready"
-    else:
-        return "You forgot OpenAI API key"
-
-def add_text(history, text):
-    history = history + [(text, None)]
-    return history, ""
-
-def bot(history):
-    response = infer(history[-1][0], history)
-    history[-1][1] = ""
-    
-    for character in response:     
-        history[-1][1] += character
-        time.sleep(0.05)
-        yield history
-    
-
-def infer(question, history):
-    
-    res = []
-    for human, ai in history[:-1]:
-        pair = (human, ai)
-        res.append(pair)
-    
-    chat_history = res
-    #print(chat_history)
-    query = question
-    result = qa({"question": query, "chat_history": chat_history})
-    #print(result)
-    return result["answer"]
-
-css="""
-#col-container {max-width: 700px; margin-left: auto; margin-right: auto;}
-"""
-
-title = """
-<div style="text-align: center;max-width: 700px;">
-    <h1>Chat with PDF • OpenAI</h1>
-    <p style="text-align: center;">Upload a .PDF from your computer, click the "Load PDF to LangChain" button, <br />
-    when everything is ready, you can start asking questions about the pdf ;) <br />
-    This version is set to store chat history, and uses OpenAI as LLM, don't forget to copy/paste your OpenAI API key</p>
-</div>
-"""
-
-
-with gr.Blocks(css=css) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.HTML(title)
-        
-        with gr.Column():
-            openai_key = gr.Textbox(label="You OpenAI API key", type="password")
-            pdf_doc = gr.File(label="Load a pdf", file_types=['.pdf'], type="file")
-            with gr.Row():
-                langchain_status = gr.Textbox(label="Status", placeholder="", interactive=False)
-                load_pdf = gr.Button("Load pdf to langchain")
-        
-        chatbot = gr.Chatbot([], elem_id="chatbot").style(height=350)
-        question = gr.Textbox(label="Question", placeholder="Type your question and hit Enter ")
-        submit_btn = gr.Button("Send Message")
-    load_pdf.click(loading_pdf, None, langchain_status, queue=False)    
-    load_pdf.click(pdf_changes, inputs=[pdf_doc, openai_key], outputs=[langchain_status], queue=False)
-    question.submit(add_text, [chatbot, question], [chatbot, question]).then(
-        bot, chatbot, chatbot
-    )
-    submit_btn.click(add_text, [chatbot, question], [chatbot, question]).then(
-        bot, chatbot, chatbot)
-
-demo.launch()
-
diff --git a/spaces/Stanlito/openvino_QandA/app.py b/spaces/Stanlito/openvino_QandA/app.py
deleted file mode 100644
index 343c08a1c6b01ff5b177d2765fcfc9d90ac99c72..0000000000000000000000000000000000000000
--- a/spaces/Stanlito/openvino_QandA/app.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import os
-import pathlib
-import re
-import gradio as gr
-from langchain.docstore.document import Document
-from langchain.document_loaders import TextLoader
-from langchain.text_splitter import CharacterTextSplitter
-from langchain.embeddings.openai import OpenAIEmbeddings
-from langchain.vectorstores import FAISS
-
-os.environ["OPENAI_API_KEY"] = "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"
-
-from langchain.prompts.chat import (
-    ChatPromptTemplate,
-    SystemMessagePromptTemplate,
-    HumanMessagePromptTemplate,
-)
-from langchain.chat_models import ChatOpenAI
-from langchain.chains import RetrievalQAWithSourcesChain
-
-# Set the data store directory
-DATA_STORE_DIR = "data_store"
-
-if os.path.exists(DATA_STORE_DIR):
-    vector_store = FAISS.load_local(
-        DATA_STORE_DIR,
-        OpenAIEmbeddings()
-    )
-else:
-    print(f"Missing files. Upload index.faiss and index.pkl files to {DATA_STORE_DIR} directory first")
-
-system_template = """Use the following pieces of context to answer the user's question.
-Take note of the sources and include them in the answer in the format: "SOURCES: source1", use "SOURCES" in capital letters regardless of the number of sources.
-If you don't know the answer, just say "I don't know", don't try to make up an answer.
-----------------
-{summaries}"""
-
-messages = [
-    SystemMessagePromptTemplate.from_template(system_template),
-    HumanMessagePromptTemplate.from_template("{question}")
-]
-prompt = ChatPromptTemplate.from_messages(messages)
-
-llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0,
-                 max_tokens=256)  # Modify model_name if you have access to GPT-4
-
-chain_type_kwargs = {"prompt": prompt}
-chain = RetrievalQAWithSourcesChain.from_chain_type(
-    llm=llm,
-    chain_type="stuff",
-    retriever=vector_store.as_retriever(),
-    return_source_documents=True,
-    chain_type_kwargs=chain_type_kwargs
-)
-
-
-def chatbot_interface(query):
-    result = chain(query)
-    return result['answer']
-
-
-# Create a Gradio interface
-gr.Interface(
-    fn=chatbot_interface,
-    inputs="text",
-    outputs="text",
-    title="LLM Chatbot",
-    description="Chat with the LLM Chatbot on Custom Data"
-).launch()
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/utils/decorators.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/utils/decorators.py
deleted file mode 100644
index bc7589cd35ceb47c41c9347cc75d9675af9d4286..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/utils/decorators.py
+++ /dev/null
@@ -1,83 +0,0 @@
-# encoding: utf-8
-"""Decorators that don't go anywhere else.
-
-This module contains misc. decorators that don't really go with another module
-in :mod:`IPython.utils`. Before putting something here please see if it should
-go into another topical module in :mod:`IPython.utils`.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from typing import Sequence
-
-from IPython.utils.docs import GENERATING_DOCUMENTATION
-
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-def flag_calls(func):
-    """Wrap a function to detect and flag when it gets called.
-
-    This is a decorator which takes a function and wraps it in a function with
-    a 'called' attribute. wrapper.called is initialized to False.
-
-    The wrapper.called attribute is set to False right before each call to the
-    wrapped function, so if the call fails it remains False.  After the call
-    completes, wrapper.called is set to True and the output is returned.
-
-    Testing for truth in wrapper.called allows you to determine if a call to
-    func() was attempted and succeeded."""
-    
-    # don't wrap twice
-    if hasattr(func, 'called'):
-        return func
-
-    def wrapper(*args,**kw):
-        wrapper.called = False
-        out = func(*args,**kw)
-        wrapper.called = True
-        return out
-
-    wrapper.called = False
-    wrapper.__doc__ = func.__doc__
-    return wrapper
-
-
-def undoc(func):
-    """Mark a function or class as undocumented.
-
-    This is found by inspecting the AST, so for now it must be used directly
-    as @undoc, not as e.g. @decorators.undoc
-    """
-    return func
-
-
-def sphinx_options(
-    show_inheritance: bool = True,
-    show_inherited_members: bool = False,
-    exclude_inherited_from: Sequence[str] = tuple(),
-):
-    """Set sphinx options"""
-
-    def wrapper(func):
-        if not GENERATING_DOCUMENTATION:
-            return func
-
-        func._sphinx_options = dict(
-            show_inheritance=show_inheritance,
-            show_inherited_members=show_inherited_members,
-            exclude_inherited_from=exclude_inherited_from,
-        )
-        return func
-
-    return wrapper
diff --git a/spaces/Supedsa/rvc-models/lib/infer_pack/commons.py b/spaces/Supedsa/rvc-models/lib/infer_pack/commons.py
deleted file mode 100644
index 54470986f37825b35d90d7efa7437d1c26b87215..0000000000000000000000000000000000000000
--- a/spaces/Supedsa/rvc-models/lib/infer_pack/commons.py
+++ /dev/null
@@ -1,166 +0,0 @@
-import math
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-
-def init_weights(m, mean=0.0, std=0.01):
-    classname = m.__class__.__name__
-    if classname.find("Conv") != -1:
-        m.weight.data.normal_(mean, std)
-
-
-def get_padding(kernel_size, dilation=1):
-    return int((kernel_size * dilation - dilation) / 2)
-
-
-def convert_pad_shape(pad_shape):
-    l = pad_shape[::-1]
-    pad_shape = [item for sublist in l for item in sublist]
-    return pad_shape
-
-
-def kl_divergence(m_p, logs_p, m_q, logs_q):
-    """KL(P||Q)"""
-    kl = (logs_q - logs_p) - 0.5
-    kl += (
-        0.5 * (torch.exp(2.0 * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2.0 * logs_q)
-    )
-    return kl
-
-
-def rand_gumbel(shape):
-    """Sample from the Gumbel distribution, protect from overflows."""
-    uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
-    return -torch.log(-torch.log(uniform_samples))
-
-
-def rand_gumbel_like(x):
-    g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
-    return g
-
-
-def slice_segments(x, ids_str, segment_size=4):
-    ret = torch.zeros_like(x[:, :, :segment_size])
-    for i in range(x.size(0)):
-        idx_str = ids_str[i]
-        idx_end = idx_str + segment_size
-        ret[i] = x[i, :, idx_str:idx_end]
-    return ret
-
-
-def slice_segments2(x, ids_str, segment_size=4):
-    ret = torch.zeros_like(x[:, :segment_size])
-    for i in range(x.size(0)):
-        idx_str = ids_str[i]
-        idx_end = idx_str + segment_size
-        ret[i] = x[i, idx_str:idx_end]
-    return ret
-
-
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
-    b, d, t = x.size()
-    if x_lengths is None:
-        x_lengths = t
-    ids_str_max = x_lengths - segment_size + 1
-    ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
-    ret = slice_segments(x, ids_str, segment_size)
-    return ret, ids_str
-
-
-def get_timing_signal_1d(length, channels, min_timescale=1.0, max_timescale=1.0e4):
-    position = torch.arange(length, dtype=torch.float)
-    num_timescales = channels // 2
-    log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / (
-        num_timescales - 1
-    )
-    inv_timescales = min_timescale * torch.exp(
-        torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment
-    )
-    scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
-    signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
-    signal = F.pad(signal, [0, 0, 0, channels % 2])
-    signal = signal.view(1, channels, length)
-    return signal
-
-
-def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
-    b, channels, length = x.size()
-    signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-    return x + signal.to(dtype=x.dtype, device=x.device)
-
-
-def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
-    b, channels, length = x.size()
-    signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-    return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
-
-
-def subsequent_mask(length):
-    mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
-    return mask
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-    n_channels_int = n_channels[0]
-    in_act = input_a + input_b
-    t_act = torch.tanh(in_act[:, :n_channels_int, :])
-    s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-    acts = t_act * s_act
-    return acts
-
-
-def convert_pad_shape(pad_shape):
-    l = pad_shape[::-1]
-    pad_shape = [item for sublist in l for item in sublist]
-    return pad_shape
-
-
-def shift_1d(x):
-    x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
-    return x
-
-
-def sequence_mask(length, max_length=None):
-    if max_length is None:
-        max_length = length.max()
-    x = torch.arange(max_length, dtype=length.dtype, device=length.device)
-    return x.unsqueeze(0) < length.unsqueeze(1)
-
-
-def generate_path(duration, mask):
-    """
-    duration: [b, 1, t_x]
-    mask: [b, 1, t_y, t_x]
-    """
-    device = duration.device
-
-    b, _, t_y, t_x = mask.shape
-    cum_duration = torch.cumsum(duration, -1)
-
-    cum_duration_flat = cum_duration.view(b * t_x)
-    path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
-    path = path.view(b, t_x, t_y)
-    path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
-    path = path.unsqueeze(1).transpose(2, 3) * mask
-    return path
-
-
-def clip_grad_value_(parameters, clip_value, norm_type=2):
-    if isinstance(parameters, torch.Tensor):
-        parameters = [parameters]
-    parameters = list(filter(lambda p: p.grad is not None, parameters))
-    norm_type = float(norm_type)
-    if clip_value is not None:
-        clip_value = float(clip_value)
-
-    total_norm = 0
-    for p in parameters:
-        param_norm = p.grad.data.norm(norm_type)
-        total_norm += param_norm.item() ** norm_type
-        if clip_value is not None:
-            p.grad.data.clamp_(min=-clip_value, max=clip_value)
-    total_norm = total_norm ** (1.0 / norm_type)
-    return total_norm
diff --git a/spaces/Superlang/ImageProcessor/annotator/oneformer/oneformer/modeling/pixel_decoder/ops/src/cpu/ms_deform_attn_cpu.cpp b/spaces/Superlang/ImageProcessor/annotator/oneformer/oneformer/modeling/pixel_decoder/ops/src/cpu/ms_deform_attn_cpu.cpp
deleted file mode 100644
index 48757e2b0156b2c1513b615d2a17e5aee5172ae7..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/oneformer/oneformer/modeling/pixel_decoder/ops/src/cpu/ms_deform_attn_cpu.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-/*!
-**************************************************************************************************
-* Deformable DETR
-* Copyright (c) 2020 SenseTime. All Rights Reserved.
-* Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-**************************************************************************************************
-* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0
-**************************************************************************************************
-*/
-
-/*!
-* Copyright (c) Facebook, Inc. and its affiliates.
-* Modified by Bowen Cheng from https://github.com/fundamentalvision/Deformable-DETR
-*/
-
-#include <vector>
-
-#include <ATen/ATen.h>
-#include <ATen/cuda/CUDAContext.h>
-
-
-at::Tensor
-ms_deform_attn_cpu_forward(
-    const at::Tensor &value, 
-    const at::Tensor &spatial_shapes,
-    const at::Tensor &level_start_index,
-    const at::Tensor &sampling_loc,
-    const at::Tensor &attn_weight,
-    const int im2col_step)
-{
-    AT_ERROR("Not implement on cpu");
-}
-
-std::vector<at::Tensor>
-ms_deform_attn_cpu_backward(
-    const at::Tensor &value, 
-    const at::Tensor &spatial_shapes,
-    const at::Tensor &level_start_index,
-    const at::Tensor &sampling_loc,
-    const at::Tensor &attn_weight,
-    const at::Tensor &grad_output,
-    const int im2col_step)
-{
-    AT_ERROR("Not implement on cpu");
-}
-
diff --git a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmseg/models/decode_heads/ema_head.py b/spaces/Superlang/ImageProcessor/annotator/uniformer/mmseg/models/decode_heads/ema_head.py
deleted file mode 100644
index 12267cb40569d2b5a4a2955a6dc2671377ff5e0a..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmseg/models/decode_heads/ema_head.py
+++ /dev/null
@@ -1,168 +0,0 @@
-import math
-
-import torch
-import torch.distributed as dist
-import torch.nn as nn
-import torch.nn.functional as F
-from annotator.uniformer.mmcv.cnn import ConvModule
-
-from ..builder import HEADS
-from .decode_head import BaseDecodeHead
-
-
-def reduce_mean(tensor):
-    """Reduce mean when distributed training."""
-    if not (dist.is_available() and dist.is_initialized()):
-        return tensor
-    tensor = tensor.clone()
-    dist.all_reduce(tensor.div_(dist.get_world_size()), op=dist.ReduceOp.SUM)
-    return tensor
-
-
-class EMAModule(nn.Module):
-    """Expectation Maximization Attention Module used in EMANet.
-
-    Args:
-        channels (int): Channels of the whole module.
-        num_bases (int): Number of bases.
-        num_stages (int): Number of the EM iterations.
-    """
-
-    def __init__(self, channels, num_bases, num_stages, momentum):
-        super(EMAModule, self).__init__()
-        assert num_stages >= 1, 'num_stages must be at least 1!'
-        self.num_bases = num_bases
-        self.num_stages = num_stages
-        self.momentum = momentum
-
-        bases = torch.zeros(1, channels, self.num_bases)
-        bases.normal_(0, math.sqrt(2. / self.num_bases))
-        # [1, channels, num_bases]
-        bases = F.normalize(bases, dim=1, p=2)
-        self.register_buffer('bases', bases)
-
-    def forward(self, feats):
-        """Forward function."""
-        batch_size, channels, height, width = feats.size()
-        # [batch_size, channels, height*width]
-        feats = feats.view(batch_size, channels, height * width)
-        # [batch_size, channels, num_bases]
-        bases = self.bases.repeat(batch_size, 1, 1)
-
-        with torch.no_grad():
-            for i in range(self.num_stages):
-                # [batch_size, height*width, num_bases]
-                attention = torch.einsum('bcn,bck->bnk', feats, bases)
-                attention = F.softmax(attention, dim=2)
-                # l1 norm
-                attention_normed = F.normalize(attention, dim=1, p=1)
-                # [batch_size, channels, num_bases]
-                bases = torch.einsum('bcn,bnk->bck', feats, attention_normed)
-                # l2 norm
-                bases = F.normalize(bases, dim=1, p=2)
-
-        feats_recon = torch.einsum('bck,bnk->bcn', bases, attention)
-        feats_recon = feats_recon.view(batch_size, channels, height, width)
-
-        if self.training:
-            bases = bases.mean(dim=0, keepdim=True)
-            bases = reduce_mean(bases)
-            # l2 norm
-            bases = F.normalize(bases, dim=1, p=2)
-            self.bases = (1 -
-                          self.momentum) * self.bases + self.momentum * bases
-
-        return feats_recon
-
-
-@HEADS.register_module()
-class EMAHead(BaseDecodeHead):
-    """Expectation Maximization Attention Networks for Semantic Segmentation.
-
-    This head is the implementation of `EMANet
-    <https://arxiv.org/abs/1907.13426>`_.
-
-    Args:
-        ema_channels (int): EMA module channels
-        num_bases (int): Number of bases.
-        num_stages (int): Number of the EM iterations.
-        concat_input (bool): Whether concat the input and output of convs
-            before classification layer. Default: True
-        momentum (float): Momentum to update the base. Default: 0.1.
-    """
-
-    def __init__(self,
-                 ema_channels,
-                 num_bases,
-                 num_stages,
-                 concat_input=True,
-                 momentum=0.1,
-                 **kwargs):
-        super(EMAHead, self).__init__(**kwargs)
-        self.ema_channels = ema_channels
-        self.num_bases = num_bases
-        self.num_stages = num_stages
-        self.concat_input = concat_input
-        self.momentum = momentum
-        self.ema_module = EMAModule(self.ema_channels, self.num_bases,
-                                    self.num_stages, self.momentum)
-
-        self.ema_in_conv = ConvModule(
-            self.in_channels,
-            self.ema_channels,
-            3,
-            padding=1,
-            conv_cfg=self.conv_cfg,
-            norm_cfg=self.norm_cfg,
-            act_cfg=self.act_cfg)
-        # project (0, inf) -> (-inf, inf)
-        self.ema_mid_conv = ConvModule(
-            self.ema_channels,
-            self.ema_channels,
-            1,
-            conv_cfg=self.conv_cfg,
-            norm_cfg=None,
-            act_cfg=None)
-        for param in self.ema_mid_conv.parameters():
-            param.requires_grad = False
-
-        self.ema_out_conv = ConvModule(
-            self.ema_channels,
-            self.ema_channels,
-            1,
-            conv_cfg=self.conv_cfg,
-            norm_cfg=self.norm_cfg,
-            act_cfg=None)
-        self.bottleneck = ConvModule(
-            self.ema_channels,
-            self.channels,
-            3,
-            padding=1,
-            conv_cfg=self.conv_cfg,
-            norm_cfg=self.norm_cfg,
-            act_cfg=self.act_cfg)
-        if self.concat_input:
-            self.conv_cat = ConvModule(
-                self.in_channels + self.channels,
-                self.channels,
-                kernel_size=3,
-                padding=1,
-                conv_cfg=self.conv_cfg,
-                norm_cfg=self.norm_cfg,
-                act_cfg=self.act_cfg)
-
-    def forward(self, inputs):
-        """Forward function."""
-        x = self._transform_inputs(inputs)
-        feats = self.ema_in_conv(x)
-        identity = feats
-        feats = self.ema_mid_conv(feats)
-        recon = self.ema_module(feats)
-        recon = F.relu(recon, inplace=True)
-        recon = self.ema_out_conv(recon)
-        output = F.relu(identity + recon, inplace=True)
-        output = self.bottleneck(output)
-        if self.concat_input:
-            output = self.conv_cat(torch.cat([x, output], dim=1))
-        output = self.cls_seg(output)
-        return output
diff --git a/spaces/Superlang/ImageProcessor/annotator/zoe/zoedepth/utils/__init__.py b/spaces/Superlang/ImageProcessor/annotator/zoe/zoedepth/utils/__init__.py
deleted file mode 100644
index 5f2668792389157609abb2a0846fb620e7d67eb9..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/zoe/zoedepth/utils/__init__.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# MIT License
-
-# Copyright (c) 2022 Intelligent Systems Lab Org
-
-# 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.
-
-# File author: Shariq Farooq Bhat
-
diff --git a/spaces/TH5314/newbing/src/lib/hooks/use-at-bottom.tsx b/spaces/TH5314/newbing/src/lib/hooks/use-at-bottom.tsx
deleted file mode 100644
index d37c8cf4162adcb0064e08ecec24eb731416b045..0000000000000000000000000000000000000000
--- a/spaces/TH5314/newbing/src/lib/hooks/use-at-bottom.tsx
+++ /dev/null
@@ -1,23 +0,0 @@
-import * as React from 'react'
-
-export function useAtBottom(offset = 0) {
-  const [isAtBottom, setIsAtBottom] = React.useState(false)
-
-  React.useEffect(() => {
-    const handleScroll = () => {
-      setIsAtBottom(
-        window.innerHeight + window.scrollY >=
-          document.body.offsetHeight - offset
-      )
-    }
-
-    window.addEventListener('scroll', handleScroll, { passive: true })
-    handleScroll()
-
-    return () => {
-      window.removeEventListener('scroll', handleScroll)
-    }
-  }, [offset])
-
-  return isAtBottom
-}
diff --git a/spaces/TRI-ML/risk_biased_prediction/tests/risk_biased/mpc_planner/test_planner_cost.py b/spaces/TRI-ML/risk_biased_prediction/tests/risk_biased/mpc_planner/test_planner_cost.py
deleted file mode 100644
index fa2774fde4b47508160ff0554c400408521424b7..0000000000000000000000000000000000000000
--- a/spaces/TRI-ML/risk_biased_prediction/tests/risk_biased/mpc_planner/test_planner_cost.py
+++ /dev/null
@@ -1,102 +0,0 @@
-from math import sqrt
-
-import pytest
-import torch
-from mmcv import Config
-
-from risk_biased.mpc_planner.planner_cost import TrackingCost, TrackingCostParams
-
-
-@pytest.fixture(scope="module")
-def params():
-    torch.manual_seed(0)
-    cfg = Config()
-
-    cfg.tracking_cost_scale_longitudinal = 0.1
-    cfg.tracking_cost_scale_lateral = 10.0
-    cfg.tracking_cost_reduce = "mean"
-
-    return cfg
-
-
-class TestTrackingCost:
-    @pytest.fixture(autouse=True)
-    def setup(self, params):
-        self.cost_params = TrackingCostParams.from_config(params)
-        self.cost = TrackingCost(self.cost_params)
-
-    @pytest.mark.parametrize("target_velocity", [[0.0, 0.0], [1.0, 1.0]])
-    def test_get_quadratic_cost_matrix(self, target_velocity):
-        target_velocity_trajectory = torch.Tensor(target_velocity).expand(10, 5, -1)
-        cost_matrix = self.cost._get_quadratic_cost_matrix(target_velocity_trajectory)
-        # test shape
-        assert cost_matrix.shape == torch.Size([10, 5, 2, 2])
-        if target_velocity == [0.0, 0.0]:
-            # make sure cost matrix is all 0 when target velocity is 0 in norm
-            assert torch.allclose(cost_matrix, torch.zeros(10, 5, 2, 2))
-        if target_velocity == [1.0, 1.0]:
-            # make sure cost matrix represents ellipse with the principal axis given by velocity
-            # direction
-            orthogonal_matrix_test = torch.Tensor(
-                [[1 / sqrt(2.0), -1 / sqrt(2.0)], [1 / sqrt(2.0), 1 / sqrt(2.0)]]
-            ).expand(10, 5, -1, -1)
-            cost_matrix_test = (
-                orthogonal_matrix_test
-                @ torch.Tensor(
-                    [
-                        [
-                            [self.cost_params.scale_longitudinal, 0.0],
-                            [0.0, self.cost_params.scale_lateral],
-                        ]
-                    ]
-                )
-                @ orthogonal_matrix_test.transpose(-1, -2)
-            )
-            assert torch.allclose(cost_matrix, cost_matrix_test)
-
-    @pytest.mark.parametrize(
-        "target_velocity, ego_position, reduce",
-        [
-            ([0.0, 0.0], [1.0, 1.0], "mean"),
-            ([0.0, 0.0], [1.0, 1.0], "max"),
-            ([0.0, 0.0], [1.0, -1.0], "mean"),
-            ([0.0, 0.0], [1.0, -1.0], "max"),
-            ([1.0, 1.0], [1.0, 1.0], "final"),
-            ([1.0, 1.0], [1.0, 1.0], "max"),
-            ([1.0, 1.0], [1.0, -1.0], "min"),
-            ([1.0, 1.0], [1.0, -1.0], "mean"),
-        ],
-    )
-    def test_call(self, target_velocity, ego_position, reduce):
-        ego_position_trajectory = torch.Tensor(ego_position).expand(10, 5, -1)
-        target_position_trajectory = torch.Tensor([0.0, 0.0]).expand(10, 5, -1)
-        target_velocity_trajectory = torch.Tensor(target_velocity).expand(10, 5, -1)
-        self.cost._reduce_fun_name = reduce
-        cost = self.cost(
-            ego_position_trajectory,
-            target_position_trajectory,
-            target_velocity_trajectory,
-        )
-        assert cost.shape == torch.Size([10])
-        if target_velocity == [0.0, 0.0]:
-            # make sure cost is zero when target velocity is 0 in norm
-            assert torch.allclose(cost, torch.zeros(10))
-        else:
-            if ego_position == [1.0, 1.0]:
-                # make sure cost is scaled with cost_scale_longitudinal when position error is
-                # aligned with target velocity direction
-                assert torch.allclose(
-                    cost,
-                    torch.Tensor(
-                        [self.cost_params.scale_longitudinal * (1.0 ** 2 + 1.0 ** 2)]
-                    ).expand(10),
-                )
-            if ego_position == [1.0, -1.0]:
-                # make sure cost is scaled with cost_scale_lateral when position error is
-                # perpendicular to target velocity direction
-                assert torch.allclose(
-                    cost,
-                    torch.Tensor(
-                        [self.cost_params.scale_lateral * (1.0 ** 2 + 1.0 ** 2)]
-                    ).expand(10),
-                )
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_internal/resolution/resolvelib/candidates.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_internal/resolution/resolvelib/candidates.py
deleted file mode 100644
index de04e1d73f2d86fb3ac094c82b9109ab71a0f917..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_internal/resolution/resolvelib/candidates.py
+++ /dev/null
@@ -1,555 +0,0 @@
-import logging
-import sys
-from typing import TYPE_CHECKING, Any, FrozenSet, Iterable, Optional, Tuple, Union, cast
-
-from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
-from pip._vendor.packaging.version import Version
-
-from pip._internal.exceptions import (
-    HashError,
-    InstallationSubprocessError,
-    MetadataInconsistent,
-)
-from pip._internal.metadata import BaseDistribution
-from pip._internal.models.link import Link, links_equivalent
-from pip._internal.models.wheel import Wheel
-from pip._internal.req.constructors import (
-    install_req_from_editable,
-    install_req_from_line,
-)
-from pip._internal.req.req_install import InstallRequirement
-from pip._internal.utils.direct_url_helpers import direct_url_from_link
-from pip._internal.utils.misc import normalize_version_info
-
-from .base import Candidate, CandidateVersion, Requirement, format_name
-
-if TYPE_CHECKING:
-    from .factory import Factory
-
-logger = logging.getLogger(__name__)
-
-BaseCandidate = Union[
-    "AlreadyInstalledCandidate",
-    "EditableCandidate",
-    "LinkCandidate",
-]
-
-# Avoid conflicting with the PyPI package "Python".
-REQUIRES_PYTHON_IDENTIFIER = cast(NormalizedName, "<Python from Requires-Python>")
-
-
-def as_base_candidate(candidate: Candidate) -> Optional[BaseCandidate]:
-    """The runtime version of BaseCandidate."""
-    base_candidate_classes = (
-        AlreadyInstalledCandidate,
-        EditableCandidate,
-        LinkCandidate,
-    )
-    if isinstance(candidate, base_candidate_classes):
-        return candidate
-    return None
-
-
-def make_install_req_from_link(
-    link: Link, template: InstallRequirement
-) -> InstallRequirement:
-    assert not template.editable, "template is editable"
-    if template.req:
-        line = str(template.req)
-    else:
-        line = link.url
-    ireq = install_req_from_line(
-        line,
-        user_supplied=template.user_supplied,
-        comes_from=template.comes_from,
-        use_pep517=template.use_pep517,
-        isolated=template.isolated,
-        constraint=template.constraint,
-        global_options=template.global_options,
-        hash_options=template.hash_options,
-        config_settings=template.config_settings,
-    )
-    ireq.original_link = template.original_link
-    ireq.link = link
-    ireq.extras = template.extras
-    return ireq
-
-
-def make_install_req_from_editable(
-    link: Link, template: InstallRequirement
-) -> InstallRequirement:
-    assert template.editable, "template not editable"
-    ireq = install_req_from_editable(
-        link.url,
-        user_supplied=template.user_supplied,
-        comes_from=template.comes_from,
-        use_pep517=template.use_pep517,
-        isolated=template.isolated,
-        constraint=template.constraint,
-        permit_editable_wheels=template.permit_editable_wheels,
-        global_options=template.global_options,
-        hash_options=template.hash_options,
-        config_settings=template.config_settings,
-    )
-    ireq.extras = template.extras
-    return ireq
-
-
-def _make_install_req_from_dist(
-    dist: BaseDistribution, template: InstallRequirement
-) -> InstallRequirement:
-    if template.req:
-        line = str(template.req)
-    elif template.link:
-        line = f"{dist.canonical_name} @ {template.link.url}"
-    else:
-        line = f"{dist.canonical_name}=={dist.version}"
-    ireq = install_req_from_line(
-        line,
-        user_supplied=template.user_supplied,
-        comes_from=template.comes_from,
-        use_pep517=template.use_pep517,
-        isolated=template.isolated,
-        constraint=template.constraint,
-        global_options=template.global_options,
-        hash_options=template.hash_options,
-        config_settings=template.config_settings,
-    )
-    ireq.satisfied_by = dist
-    return ireq
-
-
-class _InstallRequirementBackedCandidate(Candidate):
-    """A candidate backed by an ``InstallRequirement``.
-
-    This represents a package request with the target not being already
-    in the environment, and needs to be fetched and installed. The backing
-    ``InstallRequirement`` is responsible for most of the leg work; this
-    class exposes appropriate information to the resolver.
-
-    :param link: The link passed to the ``InstallRequirement``. The backing
-        ``InstallRequirement`` will use this link to fetch the distribution.
-    :param source_link: The link this candidate "originates" from. This is
-        different from ``link`` when the link is found in the wheel cache.
-        ``link`` would point to the wheel cache, while this points to the
-        found remote link (e.g. from pypi.org).
-    """
-
-    dist: BaseDistribution
-    is_installed = False
-
-    def __init__(
-        self,
-        link: Link,
-        source_link: Link,
-        ireq: InstallRequirement,
-        factory: "Factory",
-        name: Optional[NormalizedName] = None,
-        version: Optional[CandidateVersion] = None,
-    ) -> None:
-        self._link = link
-        self._source_link = source_link
-        self._factory = factory
-        self._ireq = ireq
-        self._name = name
-        self._version = version
-        self.dist = self._prepare()
-
-    def __str__(self) -> str:
-        return f"{self.name} {self.version}"
-
-    def __repr__(self) -> str:
-        return "{class_name}({link!r})".format(
-            class_name=self.__class__.__name__,
-            link=str(self._link),
-        )
-
-    def __hash__(self) -> int:
-        return hash((self.__class__, self._link))
-
-    def __eq__(self, other: Any) -> bool:
-        if isinstance(other, self.__class__):
-            return links_equivalent(self._link, other._link)
-        return False
-
-    @property
-    def source_link(self) -> Optional[Link]:
-        return self._source_link
-
-    @property
-    def project_name(self) -> NormalizedName:
-        """The normalised name of the project the candidate refers to"""
-        if self._name is None:
-            self._name = self.dist.canonical_name
-        return self._name
-
-    @property
-    def name(self) -> str:
-        return self.project_name
-
-    @property
-    def version(self) -> CandidateVersion:
-        if self._version is None:
-            self._version = self.dist.version
-        return self._version
-
-    def format_for_error(self) -> str:
-        return "{} {} (from {})".format(
-            self.name,
-            self.version,
-            self._link.file_path if self._link.is_file else self._link,
-        )
-
-    def _prepare_distribution(self) -> BaseDistribution:
-        raise NotImplementedError("Override in subclass")
-
-    def _check_metadata_consistency(self, dist: BaseDistribution) -> None:
-        """Check for consistency of project name and version of dist."""
-        if self._name is not None and self._name != dist.canonical_name:
-            raise MetadataInconsistent(
-                self._ireq,
-                "name",
-                self._name,
-                dist.canonical_name,
-            )
-        if self._version is not None and self._version != dist.version:
-            raise MetadataInconsistent(
-                self._ireq,
-                "version",
-                str(self._version),
-                str(dist.version),
-            )
-
-    def _prepare(self) -> BaseDistribution:
-        try:
-            dist = self._prepare_distribution()
-        except HashError as e:
-            # Provide HashError the underlying ireq that caused it. This
-            # provides context for the resulting error message to show the
-            # offending line to the user.
-            e.req = self._ireq
-            raise
-        except InstallationSubprocessError as exc:
-            # The output has been presented already, so don't duplicate it.
-            exc.context = "See above for output."
-            raise
-
-        self._check_metadata_consistency(dist)
-        return dist
-
-    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
-        requires = self.dist.iter_dependencies() if with_requires else ()
-        for r in requires:
-            yield self._factory.make_requirement_from_spec(str(r), self._ireq)
-        yield self._factory.make_requires_python_requirement(self.dist.requires_python)
-
-    def get_install_requirement(self) -> Optional[InstallRequirement]:
-        return self._ireq
-
-
-class LinkCandidate(_InstallRequirementBackedCandidate):
-    is_editable = False
-
-    def __init__(
-        self,
-        link: Link,
-        template: InstallRequirement,
-        factory: "Factory",
-        name: Optional[NormalizedName] = None,
-        version: Optional[CandidateVersion] = None,
-    ) -> None:
-        source_link = link
-        cache_entry = factory.get_wheel_cache_entry(source_link, name)
-        if cache_entry is not None:
-            logger.debug("Using cached wheel link: %s", cache_entry.link)
-            link = cache_entry.link
-        ireq = make_install_req_from_link(link, template)
-        assert ireq.link == link
-        if ireq.link.is_wheel and not ireq.link.is_file:
-            wheel = Wheel(ireq.link.filename)
-            wheel_name = canonicalize_name(wheel.name)
-            assert name == wheel_name, f"{name!r} != {wheel_name!r} for wheel"
-            # Version may not be present for PEP 508 direct URLs
-            if version is not None:
-                wheel_version = Version(wheel.version)
-                assert version == wheel_version, "{!r} != {!r} for wheel {}".format(
-                    version, wheel_version, name
-                )
-
-        if cache_entry is not None:
-            assert ireq.link.is_wheel
-            assert ireq.link.is_file
-            if cache_entry.persistent and template.link is template.original_link:
-                ireq.cached_wheel_source_link = source_link
-            if cache_entry.origin is not None:
-                ireq.download_info = cache_entry.origin
-            else:
-                # Legacy cache entry that does not have origin.json.
-                # download_info may miss the archive_info.hashes field.
-                ireq.download_info = direct_url_from_link(
-                    source_link, link_is_in_wheel_cache=cache_entry.persistent
-                )
-
-        super().__init__(
-            link=link,
-            source_link=source_link,
-            ireq=ireq,
-            factory=factory,
-            name=name,
-            version=version,
-        )
-
-    def _prepare_distribution(self) -> BaseDistribution:
-        preparer = self._factory.preparer
-        return preparer.prepare_linked_requirement(self._ireq, parallel_builds=True)
-
-
-class EditableCandidate(_InstallRequirementBackedCandidate):
-    is_editable = True
-
-    def __init__(
-        self,
-        link: Link,
-        template: InstallRequirement,
-        factory: "Factory",
-        name: Optional[NormalizedName] = None,
-        version: Optional[CandidateVersion] = None,
-    ) -> None:
-        super().__init__(
-            link=link,
-            source_link=link,
-            ireq=make_install_req_from_editable(link, template),
-            factory=factory,
-            name=name,
-            version=version,
-        )
-
-    def _prepare_distribution(self) -> BaseDistribution:
-        return self._factory.preparer.prepare_editable_requirement(self._ireq)
-
-
-class AlreadyInstalledCandidate(Candidate):
-    is_installed = True
-    source_link = None
-
-    def __init__(
-        self,
-        dist: BaseDistribution,
-        template: InstallRequirement,
-        factory: "Factory",
-    ) -> None:
-        self.dist = dist
-        self._ireq = _make_install_req_from_dist(dist, template)
-        self._factory = factory
-        self._version = None
-
-        # This is just logging some messages, so we can do it eagerly.
-        # The returned dist would be exactly the same as self.dist because we
-        # set satisfied_by in _make_install_req_from_dist.
-        # TODO: Supply reason based on force_reinstall and upgrade_strategy.
-        skip_reason = "already satisfied"
-        factory.preparer.prepare_installed_requirement(self._ireq, skip_reason)
-
-    def __str__(self) -> str:
-        return str(self.dist)
-
-    def __repr__(self) -> str:
-        return "{class_name}({distribution!r})".format(
-            class_name=self.__class__.__name__,
-            distribution=self.dist,
-        )
-
-    def __hash__(self) -> int:
-        return hash((self.__class__, self.name, self.version))
-
-    def __eq__(self, other: Any) -> bool:
-        if isinstance(other, self.__class__):
-            return self.name == other.name and self.version == other.version
-        return False
-
-    @property
-    def project_name(self) -> NormalizedName:
-        return self.dist.canonical_name
-
-    @property
-    def name(self) -> str:
-        return self.project_name
-
-    @property
-    def version(self) -> CandidateVersion:
-        if self._version is None:
-            self._version = self.dist.version
-        return self._version
-
-    @property
-    def is_editable(self) -> bool:
-        return self.dist.editable
-
-    def format_for_error(self) -> str:
-        return f"{self.name} {self.version} (Installed)"
-
-    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
-        if not with_requires:
-            return
-        for r in self.dist.iter_dependencies():
-            yield self._factory.make_requirement_from_spec(str(r), self._ireq)
-
-    def get_install_requirement(self) -> Optional[InstallRequirement]:
-        return None
-
-
-class ExtrasCandidate(Candidate):
-    """A candidate that has 'extras', indicating additional dependencies.
-
-    Requirements can be for a project with dependencies, something like
-    foo[extra].  The extras don't affect the project/version being installed
-    directly, but indicate that we need additional dependencies. We model that
-    by having an artificial ExtrasCandidate that wraps the "base" candidate.
-
-    The ExtrasCandidate differs from the base in the following ways:
-
-    1. It has a unique name, of the form foo[extra]. This causes the resolver
-       to treat it as a separate node in the dependency graph.
-    2. When we're getting the candidate's dependencies,
-       a) We specify that we want the extra dependencies as well.
-       b) We add a dependency on the base candidate.
-          See below for why this is needed.
-    3. We return None for the underlying InstallRequirement, as the base
-       candidate will provide it, and we don't want to end up with duplicates.
-
-    The dependency on the base candidate is needed so that the resolver can't
-    decide that it should recommend foo[extra1] version 1.0 and foo[extra2]
-    version 2.0. Having those candidates depend on foo=1.0 and foo=2.0
-    respectively forces the resolver to recognise that this is a conflict.
-    """
-
-    def __init__(
-        self,
-        base: BaseCandidate,
-        extras: FrozenSet[str],
-    ) -> None:
-        self.base = base
-        self.extras = extras
-
-    def __str__(self) -> str:
-        name, rest = str(self.base).split(" ", 1)
-        return "{}[{}] {}".format(name, ",".join(self.extras), rest)
-
-    def __repr__(self) -> str:
-        return "{class_name}(base={base!r}, extras={extras!r})".format(
-            class_name=self.__class__.__name__,
-            base=self.base,
-            extras=self.extras,
-        )
-
-    def __hash__(self) -> int:
-        return hash((self.base, self.extras))
-
-    def __eq__(self, other: Any) -> bool:
-        if isinstance(other, self.__class__):
-            return self.base == other.base and self.extras == other.extras
-        return False
-
-    @property
-    def project_name(self) -> NormalizedName:
-        return self.base.project_name
-
-    @property
-    def name(self) -> str:
-        """The normalised name of the project the candidate refers to"""
-        return format_name(self.base.project_name, self.extras)
-
-    @property
-    def version(self) -> CandidateVersion:
-        return self.base.version
-
-    def format_for_error(self) -> str:
-        return "{} [{}]".format(
-            self.base.format_for_error(), ", ".join(sorted(self.extras))
-        )
-
-    @property
-    def is_installed(self) -> bool:
-        return self.base.is_installed
-
-    @property
-    def is_editable(self) -> bool:
-        return self.base.is_editable
-
-    @property
-    def source_link(self) -> Optional[Link]:
-        return self.base.source_link
-
-    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
-        factory = self.base._factory
-
-        # Add a dependency on the exact base
-        # (See note 2b in the class docstring)
-        yield factory.make_requirement_from_candidate(self.base)
-        if not with_requires:
-            return
-
-        # The user may have specified extras that the candidate doesn't
-        # support. We ignore any unsupported extras here.
-        valid_extras = self.extras.intersection(self.base.dist.iter_provided_extras())
-        invalid_extras = self.extras.difference(self.base.dist.iter_provided_extras())
-        for extra in sorted(invalid_extras):
-            logger.warning(
-                "%s %s does not provide the extra '%s'",
-                self.base.name,
-                self.version,
-                extra,
-            )
-
-        for r in self.base.dist.iter_dependencies(valid_extras):
-            requirement = factory.make_requirement_from_spec(
-                str(r), self.base._ireq, valid_extras
-            )
-            if requirement:
-                yield requirement
-
-    def get_install_requirement(self) -> Optional[InstallRequirement]:
-        # We don't return anything here, because we always
-        # depend on the base candidate, and we'll get the
-        # install requirement from that.
-        return None
-
-
-class RequiresPythonCandidate(Candidate):
-    is_installed = False
-    source_link = None
-
-    def __init__(self, py_version_info: Optional[Tuple[int, ...]]) -> None:
-        if py_version_info is not None:
-            version_info = normalize_version_info(py_version_info)
-        else:
-            version_info = sys.version_info[:3]
-        self._version = Version(".".join(str(c) for c in version_info))
-
-    # We don't need to implement __eq__() and __ne__() since there is always
-    # only one RequiresPythonCandidate in a resolution, i.e. the host Python.
-    # The built-in object.__eq__() and object.__ne__() do exactly what we want.
-
-    def __str__(self) -> str:
-        return f"Python {self._version}"
-
-    @property
-    def project_name(self) -> NormalizedName:
-        return REQUIRES_PYTHON_IDENTIFIER
-
-    @property
-    def name(self) -> str:
-        return REQUIRES_PYTHON_IDENTIFIER
-
-    @property
-    def version(self) -> CandidateVersion:
-        return self._version
-
-    def format_for_error(self) -> str:
-        return f"Python {self.version}"
-
-    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
-        return ()
-
-    def get_install_requirement(self) -> Optional[InstallRequirement]:
-        return None
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/distlib/locators.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/distlib/locators.py
deleted file mode 100644
index 966ebc0e37d6104a8e0e1fefe9dc526f39409ce2..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/distlib/locators.py
+++ /dev/null
@@ -1,1300 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2012-2015 Vinay Sajip.
-# Licensed to the Python Software Foundation under a contributor agreement.
-# See LICENSE.txt and CONTRIBUTORS.txt.
-#
-
-import gzip
-from io import BytesIO
-import json
-import logging
-import os
-import posixpath
-import re
-try:
-    import threading
-except ImportError:  # pragma: no cover
-    import dummy_threading as threading
-import zlib
-
-from . import DistlibException
-from .compat import (urljoin, urlparse, urlunparse, url2pathname, pathname2url,
-                     queue, quote, unescape, build_opener,
-                     HTTPRedirectHandler as BaseRedirectHandler, text_type,
-                     Request, HTTPError, URLError)
-from .database import Distribution, DistributionPath, make_dist
-from .metadata import Metadata, MetadataInvalidError
-from .util import (cached_property, ensure_slash, split_filename, get_project_data,
-                   parse_requirement, parse_name_and_version, ServerProxy,
-                   normalize_name)
-from .version import get_scheme, UnsupportedVersionError
-from .wheel import Wheel, is_compatible
-
-logger = logging.getLogger(__name__)
-
-HASHER_HASH = re.compile(r'^(\w+)=([a-f0-9]+)')
-CHARSET = re.compile(r';\s*charset\s*=\s*(.*)\s*$', re.I)
-HTML_CONTENT_TYPE = re.compile('text/html|application/x(ht)?ml')
-DEFAULT_INDEX = 'https://pypi.org/pypi'
-
-def get_all_distribution_names(url=None):
-    """
-    Return all distribution names known by an index.
-    :param url: The URL of the index.
-    :return: A list of all known distribution names.
-    """
-    if url is None:
-        url = DEFAULT_INDEX
-    client = ServerProxy(url, timeout=3.0)
-    try:
-        return client.list_packages()
-    finally:
-        client('close')()
-
-class RedirectHandler(BaseRedirectHandler):
-    """
-    A class to work around a bug in some Python 3.2.x releases.
-    """
-    # There's a bug in the base version for some 3.2.x
-    # (e.g. 3.2.2 on Ubuntu Oneiric). If a Location header
-    # returns e.g. /abc, it bails because it says the scheme ''
-    # is bogus, when actually it should use the request's
-    # URL for the scheme. See Python issue #13696.
-    def http_error_302(self, req, fp, code, msg, headers):
-        # Some servers (incorrectly) return multiple Location headers
-        # (so probably same goes for URI).  Use first header.
-        newurl = None
-        for key in ('location', 'uri'):
-            if key in headers:
-                newurl = headers[key]
-                break
-        if newurl is None:  # pragma: no cover
-            return
-        urlparts = urlparse(newurl)
-        if urlparts.scheme == '':
-            newurl = urljoin(req.get_full_url(), newurl)
-            if hasattr(headers, 'replace_header'):
-                headers.replace_header(key, newurl)
-            else:
-                headers[key] = newurl
-        return BaseRedirectHandler.http_error_302(self, req, fp, code, msg,
-                                                  headers)
-
-    http_error_301 = http_error_303 = http_error_307 = http_error_302
-
-class Locator(object):
-    """
-    A base class for locators - things that locate distributions.
-    """
-    source_extensions = ('.tar.gz', '.tar.bz2', '.tar', '.zip', '.tgz', '.tbz')
-    binary_extensions = ('.egg', '.exe', '.whl')
-    excluded_extensions = ('.pdf',)
-
-    # A list of tags indicating which wheels you want to match. The default
-    # value of None matches against the tags compatible with the running
-    # Python. If you want to match other values, set wheel_tags on a locator
-    # instance to a list of tuples (pyver, abi, arch) which you want to match.
-    wheel_tags = None
-
-    downloadable_extensions = source_extensions + ('.whl',)
-
-    def __init__(self, scheme='default'):
-        """
-        Initialise an instance.
-        :param scheme: Because locators look for most recent versions, they
-                       need to know the version scheme to use. This specifies
-                       the current PEP-recommended scheme - use ``'legacy'``
-                       if you need to support existing distributions on PyPI.
-        """
-        self._cache = {}
-        self.scheme = scheme
-        # Because of bugs in some of the handlers on some of the platforms,
-        # we use our own opener rather than just using urlopen.
-        self.opener = build_opener(RedirectHandler())
-        # If get_project() is called from locate(), the matcher instance
-        # is set from the requirement passed to locate(). See issue #18 for
-        # why this can be useful to know.
-        self.matcher = None
-        self.errors = queue.Queue()
-
-    def get_errors(self):
-        """
-        Return any errors which have occurred.
-        """
-        result = []
-        while not self.errors.empty():  # pragma: no cover
-            try:
-                e = self.errors.get(False)
-                result.append(e)
-            except self.errors.Empty:
-                continue
-            self.errors.task_done()
-        return result
-
-    def clear_errors(self):
-        """
-        Clear any errors which may have been logged.
-        """
-        # Just get the errors and throw them away
-        self.get_errors()
-
-    def clear_cache(self):
-        self._cache.clear()
-
-    def _get_scheme(self):
-        return self._scheme
-
-    def _set_scheme(self, value):
-        self._scheme = value
-
-    scheme = property(_get_scheme, _set_scheme)
-
-    def _get_project(self, name):
-        """
-        For a given project, get a dictionary mapping available versions to Distribution
-        instances.
-
-        This should be implemented in subclasses.
-
-        If called from a locate() request, self.matcher will be set to a
-        matcher for the requirement to satisfy, otherwise it will be None.
-        """
-        raise NotImplementedError('Please implement in the subclass')
-
-    def get_distribution_names(self):
-        """
-        Return all the distribution names known to this locator.
-        """
-        raise NotImplementedError('Please implement in the subclass')
-
-    def get_project(self, name):
-        """
-        For a given project, get a dictionary mapping available versions to Distribution
-        instances.
-
-        This calls _get_project to do all the work, and just implements a caching layer on top.
-        """
-        if self._cache is None:  # pragma: no cover
-            result = self._get_project(name)
-        elif name in self._cache:
-            result = self._cache[name]
-        else:
-            self.clear_errors()
-            result = self._get_project(name)
-            self._cache[name] = result
-        return result
-
-    def score_url(self, url):
-        """
-        Give an url a score which can be used to choose preferred URLs
-        for a given project release.
-        """
-        t = urlparse(url)
-        basename = posixpath.basename(t.path)
-        compatible = True
-        is_wheel = basename.endswith('.whl')
-        is_downloadable = basename.endswith(self.downloadable_extensions)
-        if is_wheel:
-            compatible = is_compatible(Wheel(basename), self.wheel_tags)
-        return (t.scheme == 'https', 'pypi.org' in t.netloc,
-                is_downloadable, is_wheel, compatible, basename)
-
-    def prefer_url(self, url1, url2):
-        """
-        Choose one of two URLs where both are candidates for distribution
-        archives for the same version of a distribution (for example,
-        .tar.gz vs. zip).
-
-        The current implementation favours https:// URLs over http://, archives
-        from PyPI over those from other locations, wheel compatibility (if a
-        wheel) and then the archive name.
-        """
-        result = url2
-        if url1:
-            s1 = self.score_url(url1)
-            s2 = self.score_url(url2)
-            if s1 > s2:
-                result = url1
-            if result != url2:
-                logger.debug('Not replacing %r with %r', url1, url2)
-            else:
-                logger.debug('Replacing %r with %r', url1, url2)
-        return result
-
-    def split_filename(self, filename, project_name):
-        """
-        Attempt to split a filename in project name, version and Python version.
-        """
-        return split_filename(filename, project_name)
-
-    def convert_url_to_download_info(self, url, project_name):
-        """
-        See if a URL is a candidate for a download URL for a project (the URL
-        has typically been scraped from an HTML page).
-
-        If it is, a dictionary is returned with keys "name", "version",
-        "filename" and "url"; otherwise, None is returned.
-        """
-        def same_project(name1, name2):
-            return normalize_name(name1) == normalize_name(name2)
-
-        result = None
-        scheme, netloc, path, params, query, frag = urlparse(url)
-        if frag.lower().startswith('egg='):  # pragma: no cover
-            logger.debug('%s: version hint in fragment: %r',
-                         project_name, frag)
-        m = HASHER_HASH.match(frag)
-        if m:
-            algo, digest = m.groups()
-        else:
-            algo, digest = None, None
-        origpath = path
-        if path and path[-1] == '/':  # pragma: no cover
-            path = path[:-1]
-        if path.endswith('.whl'):
-            try:
-                wheel = Wheel(path)
-                if not is_compatible(wheel, self.wheel_tags):
-                    logger.debug('Wheel not compatible: %s', path)
-                else:
-                    if project_name is None:
-                        include = True
-                    else:
-                        include = same_project(wheel.name, project_name)
-                    if include:
-                        result = {
-                            'name': wheel.name,
-                            'version': wheel.version,
-                            'filename': wheel.filename,
-                            'url': urlunparse((scheme, netloc, origpath,
-                                               params, query, '')),
-                            'python-version': ', '.join(
-                                ['.'.join(list(v[2:])) for v in wheel.pyver]),
-                        }
-            except Exception as e:  # pragma: no cover
-                logger.warning('invalid path for wheel: %s', path)
-        elif not path.endswith(self.downloadable_extensions):  # pragma: no cover
-            logger.debug('Not downloadable: %s', path)
-        else:  # downloadable extension
-            path = filename = posixpath.basename(path)
-            for ext in self.downloadable_extensions:
-                if path.endswith(ext):
-                    path = path[:-len(ext)]
-                    t = self.split_filename(path, project_name)
-                    if not t:  # pragma: no cover
-                        logger.debug('No match for project/version: %s', path)
-                    else:
-                        name, version, pyver = t
-                        if not project_name or same_project(project_name, name):
-                            result = {
-                                'name': name,
-                                'version': version,
-                                'filename': filename,
-                                'url': urlunparse((scheme, netloc, origpath,
-                                                   params, query, '')),
-                                #'packagetype': 'sdist',
-                            }
-                            if pyver:  # pragma: no cover
-                                result['python-version'] = pyver
-                    break
-        if result and algo:
-            result['%s_digest' % algo] = digest
-        return result
-
-    def _get_digest(self, info):
-        """
-        Get a digest from a dictionary by looking at a "digests" dictionary
-        or keys of the form 'algo_digest'.
-
-        Returns a 2-tuple (algo, digest) if found, else None. Currently
-        looks only for SHA256, then MD5.
-        """
-        result = None
-        if 'digests' in info:
-            digests = info['digests']
-            for algo in ('sha256', 'md5'):
-                if algo in digests:
-                    result = (algo, digests[algo])
-                    break
-        if not result:
-            for algo in ('sha256', 'md5'):
-                key = '%s_digest' % algo
-                if key in info:
-                    result = (algo, info[key])
-                    break
-        return result
-
-    def _update_version_data(self, result, info):
-        """
-        Update a result dictionary (the final result from _get_project) with a
-        dictionary for a specific version, which typically holds information
-        gleaned from a filename or URL for an archive for the distribution.
-        """
-        name = info.pop('name')
-        version = info.pop('version')
-        if version in result:
-            dist = result[version]
-            md = dist.metadata
-        else:
-            dist = make_dist(name, version, scheme=self.scheme)
-            md = dist.metadata
-        dist.digest = digest = self._get_digest(info)
-        url = info['url']
-        result['digests'][url] = digest
-        if md.source_url != info['url']:
-            md.source_url = self.prefer_url(md.source_url, url)
-            result['urls'].setdefault(version, set()).add(url)
-        dist.locator = self
-        result[version] = dist
-
-    def locate(self, requirement, prereleases=False):
-        """
-        Find the most recent distribution which matches the given
-        requirement.
-
-        :param requirement: A requirement of the form 'foo (1.0)' or perhaps
-                            'foo (>= 1.0, < 2.0, != 1.3)'
-        :param prereleases: If ``True``, allow pre-release versions
-                            to be located. Otherwise, pre-release versions
-                            are not returned.
-        :return: A :class:`Distribution` instance, or ``None`` if no such
-                 distribution could be located.
-        """
-        result = None
-        r = parse_requirement(requirement)
-        if r is None:  # pragma: no cover
-            raise DistlibException('Not a valid requirement: %r' % requirement)
-        scheme = get_scheme(self.scheme)
-        self.matcher = matcher = scheme.matcher(r.requirement)
-        logger.debug('matcher: %s (%s)', matcher, type(matcher).__name__)
-        versions = self.get_project(r.name)
-        if len(versions) > 2:   # urls and digests keys are present
-            # sometimes, versions are invalid
-            slist = []
-            vcls = matcher.version_class
-            for k in versions:
-                if k in ('urls', 'digests'):
-                    continue
-                try:
-                    if not matcher.match(k):
-                        pass  # logger.debug('%s did not match %r', matcher, k)
-                    else:
-                        if prereleases or not vcls(k).is_prerelease:
-                            slist.append(k)
-                        # else:
-                            # logger.debug('skipping pre-release '
-                                         # 'version %s of %s', k, matcher.name)
-                except Exception:  # pragma: no cover
-                    logger.warning('error matching %s with %r', matcher, k)
-                    pass # slist.append(k)
-            if len(slist) > 1:
-                slist = sorted(slist, key=scheme.key)
-            if slist:
-                logger.debug('sorted list: %s', slist)
-                version = slist[-1]
-                result = versions[version]
-        if result:
-            if r.extras:
-                result.extras = r.extras
-            result.download_urls = versions.get('urls', {}).get(version, set())
-            d = {}
-            sd = versions.get('digests', {})
-            for url in result.download_urls:
-                if url in sd:  # pragma: no cover
-                    d[url] = sd[url]
-            result.digests = d
-        self.matcher = None
-        return result
-
-
-class PyPIRPCLocator(Locator):
-    """
-    This locator uses XML-RPC to locate distributions. It therefore
-    cannot be used with simple mirrors (that only mirror file content).
-    """
-    def __init__(self, url, **kwargs):
-        """
-        Initialise an instance.
-
-        :param url: The URL to use for XML-RPC.
-        :param kwargs: Passed to the superclass constructor.
-        """
-        super(PyPIRPCLocator, self).__init__(**kwargs)
-        self.base_url = url
-        self.client = ServerProxy(url, timeout=3.0)
-
-    def get_distribution_names(self):
-        """
-        Return all the distribution names known to this locator.
-        """
-        return set(self.client.list_packages())
-
-    def _get_project(self, name):
-        result = {'urls': {}, 'digests': {}}
-        versions = self.client.package_releases(name, True)
-        for v in versions:
-            urls = self.client.release_urls(name, v)
-            data = self.client.release_data(name, v)
-            metadata = Metadata(scheme=self.scheme)
-            metadata.name = data['name']
-            metadata.version = data['version']
-            metadata.license = data.get('license')
-            metadata.keywords = data.get('keywords', [])
-            metadata.summary = data.get('summary')
-            dist = Distribution(metadata)
-            if urls:
-                info = urls[0]
-                metadata.source_url = info['url']
-                dist.digest = self._get_digest(info)
-                dist.locator = self
-                result[v] = dist
-                for info in urls:
-                    url = info['url']
-                    digest = self._get_digest(info)
-                    result['urls'].setdefault(v, set()).add(url)
-                    result['digests'][url] = digest
-        return result
-
-class PyPIJSONLocator(Locator):
-    """
-    This locator uses PyPI's JSON interface. It's very limited in functionality
-    and probably not worth using.
-    """
-    def __init__(self, url, **kwargs):
-        super(PyPIJSONLocator, self).__init__(**kwargs)
-        self.base_url = ensure_slash(url)
-
-    def get_distribution_names(self):
-        """
-        Return all the distribution names known to this locator.
-        """
-        raise NotImplementedError('Not available from this locator')
-
-    def _get_project(self, name):
-        result = {'urls': {}, 'digests': {}}
-        url = urljoin(self.base_url, '%s/json' % quote(name))
-        try:
-            resp = self.opener.open(url)
-            data = resp.read().decode() # for now
-            d = json.loads(data)
-            md = Metadata(scheme=self.scheme)
-            data = d['info']
-            md.name = data['name']
-            md.version = data['version']
-            md.license = data.get('license')
-            md.keywords = data.get('keywords', [])
-            md.summary = data.get('summary')
-            dist = Distribution(md)
-            dist.locator = self
-            urls = d['urls']
-            result[md.version] = dist
-            for info in d['urls']:
-                url = info['url']
-                dist.download_urls.add(url)
-                dist.digests[url] = self._get_digest(info)
-                result['urls'].setdefault(md.version, set()).add(url)
-                result['digests'][url] = self._get_digest(info)
-            # Now get other releases
-            for version, infos in d['releases'].items():
-                if version == md.version:
-                    continue    # already done
-                omd = Metadata(scheme=self.scheme)
-                omd.name = md.name
-                omd.version = version
-                odist = Distribution(omd)
-                odist.locator = self
-                result[version] = odist
-                for info in infos:
-                    url = info['url']
-                    odist.download_urls.add(url)
-                    odist.digests[url] = self._get_digest(info)
-                    result['urls'].setdefault(version, set()).add(url)
-                    result['digests'][url] = self._get_digest(info)
-#            for info in urls:
-#                md.source_url = info['url']
-#                dist.digest = self._get_digest(info)
-#                dist.locator = self
-#                for info in urls:
-#                    url = info['url']
-#                    result['urls'].setdefault(md.version, set()).add(url)
-#                    result['digests'][url] = self._get_digest(info)
-        except Exception as e:
-            self.errors.put(text_type(e))
-            logger.exception('JSON fetch failed: %s', e)
-        return result
-
-
-class Page(object):
-    """
-    This class represents a scraped HTML page.
-    """
-    # The following slightly hairy-looking regex just looks for the contents of
-    # an anchor link, which has an attribute "href" either immediately preceded
-    # or immediately followed by a "rel" attribute. The attribute values can be
-    # declared with double quotes, single quotes or no quotes - which leads to
-    # the length of the expression.
-    _href = re.compile("""
-(rel\\s*=\\s*(?:"(?P<rel1>[^"]*)"|'(?P<rel2>[^']*)'|(?P<rel3>[^>\\s\n]*))\\s+)?
-href\\s*=\\s*(?:"(?P<url1>[^"]*)"|'(?P<url2>[^']*)'|(?P<url3>[^>\\s\n]*))
-(\\s+rel\\s*=\\s*(?:"(?P<rel4>[^"]*)"|'(?P<rel5>[^']*)'|(?P<rel6>[^>\\s\n]*)))?
-""", re.I | re.S | re.X)
-    _base = re.compile(r"""<base\s+href\s*=\s*['"]?([^'">]+)""", re.I | re.S)
-
-    def __init__(self, data, url):
-        """
-        Initialise an instance with the Unicode page contents and the URL they
-        came from.
-        """
-        self.data = data
-        self.base_url = self.url = url
-        m = self._base.search(self.data)
-        if m:
-            self.base_url = m.group(1)
-
-    _clean_re = re.compile(r'[^a-z0-9$&+,/:;=?@.#%_\\|-]', re.I)
-
-    @cached_property
-    def links(self):
-        """
-        Return the URLs of all the links on a page together with information
-        about their "rel" attribute, for determining which ones to treat as
-        downloads and which ones to queue for further scraping.
-        """
-        def clean(url):
-            "Tidy up an URL."
-            scheme, netloc, path, params, query, frag = urlparse(url)
-            return urlunparse((scheme, netloc, quote(path),
-                               params, query, frag))
-
-        result = set()
-        for match in self._href.finditer(self.data):
-            d = match.groupdict('')
-            rel = (d['rel1'] or d['rel2'] or d['rel3'] or
-                   d['rel4'] or d['rel5'] or d['rel6'])
-            url = d['url1'] or d['url2'] or d['url3']
-            url = urljoin(self.base_url, url)
-            url = unescape(url)
-            url = self._clean_re.sub(lambda m: '%%%2x' % ord(m.group(0)), url)
-            result.add((url, rel))
-        # We sort the result, hoping to bring the most recent versions
-        # to the front
-        result = sorted(result, key=lambda t: t[0], reverse=True)
-        return result
-
-
-class SimpleScrapingLocator(Locator):
-    """
-    A locator which scrapes HTML pages to locate downloads for a distribution.
-    This runs multiple threads to do the I/O; performance is at least as good
-    as pip's PackageFinder, which works in an analogous fashion.
-    """
-
-    # These are used to deal with various Content-Encoding schemes.
-    decoders = {
-        'deflate': zlib.decompress,
-        'gzip': lambda b: gzip.GzipFile(fileobj=BytesIO(b)).read(),
-        'none': lambda b: b,
-    }
-
-    def __init__(self, url, timeout=None, num_workers=10, **kwargs):
-        """
-        Initialise an instance.
-        :param url: The root URL to use for scraping.
-        :param timeout: The timeout, in seconds, to be applied to requests.
-                        This defaults to ``None`` (no timeout specified).
-        :param num_workers: The number of worker threads you want to do I/O,
-                            This defaults to 10.
-        :param kwargs: Passed to the superclass.
-        """
-        super(SimpleScrapingLocator, self).__init__(**kwargs)
-        self.base_url = ensure_slash(url)
-        self.timeout = timeout
-        self._page_cache = {}
-        self._seen = set()
-        self._to_fetch = queue.Queue()
-        self._bad_hosts = set()
-        self.skip_externals = False
-        self.num_workers = num_workers
-        self._lock = threading.RLock()
-        # See issue #45: we need to be resilient when the locator is used
-        # in a thread, e.g. with concurrent.futures. We can't use self._lock
-        # as it is for coordinating our internal threads - the ones created
-        # in _prepare_threads.
-        self._gplock = threading.RLock()
-        self.platform_check = False  # See issue #112
-
-    def _prepare_threads(self):
-        """
-        Threads are created only when get_project is called, and terminate
-        before it returns. They are there primarily to parallelise I/O (i.e.
-        fetching web pages).
-        """
-        self._threads = []
-        for i in range(self.num_workers):
-            t = threading.Thread(target=self._fetch)
-            t.daemon = True
-            t.start()
-            self._threads.append(t)
-
-    def _wait_threads(self):
-        """
-        Tell all the threads to terminate (by sending a sentinel value) and
-        wait for them to do so.
-        """
-        # Note that you need two loops, since you can't say which
-        # thread will get each sentinel
-        for t in self._threads:
-            self._to_fetch.put(None)    # sentinel
-        for t in self._threads:
-            t.join()
-        self._threads = []
-
-    def _get_project(self, name):
-        result = {'urls': {}, 'digests': {}}
-        with self._gplock:
-            self.result = result
-            self.project_name = name
-            url = urljoin(self.base_url, '%s/' % quote(name))
-            self._seen.clear()
-            self._page_cache.clear()
-            self._prepare_threads()
-            try:
-                logger.debug('Queueing %s', url)
-                self._to_fetch.put(url)
-                self._to_fetch.join()
-            finally:
-                self._wait_threads()
-            del self.result
-        return result
-
-    platform_dependent = re.compile(r'\b(linux_(i\d86|x86_64|arm\w+)|'
-                                    r'win(32|_amd64)|macosx_?\d+)\b', re.I)
-
-    def _is_platform_dependent(self, url):
-        """
-        Does an URL refer to a platform-specific download?
-        """
-        return self.platform_dependent.search(url)
-
-    def _process_download(self, url):
-        """
-        See if an URL is a suitable download for a project.
-
-        If it is, register information in the result dictionary (for
-        _get_project) about the specific version it's for.
-
-        Note that the return value isn't actually used other than as a boolean
-        value.
-        """
-        if self.platform_check and self._is_platform_dependent(url):
-            info = None
-        else:
-            info = self.convert_url_to_download_info(url, self.project_name)
-        logger.debug('process_download: %s -> %s', url, info)
-        if info:
-            with self._lock:    # needed because self.result is shared
-                self._update_version_data(self.result, info)
-        return info
-
-    def _should_queue(self, link, referrer, rel):
-        """
-        Determine whether a link URL from a referring page and with a
-        particular "rel" attribute should be queued for scraping.
-        """
-        scheme, netloc, path, _, _, _ = urlparse(link)
-        if path.endswith(self.source_extensions + self.binary_extensions +
-                         self.excluded_extensions):
-            result = False
-        elif self.skip_externals and not link.startswith(self.base_url):
-            result = False
-        elif not referrer.startswith(self.base_url):
-            result = False
-        elif rel not in ('homepage', 'download'):
-            result = False
-        elif scheme not in ('http', 'https', 'ftp'):
-            result = False
-        elif self._is_platform_dependent(link):
-            result = False
-        else:
-            host = netloc.split(':', 1)[0]
-            if host.lower() == 'localhost':
-                result = False
-            else:
-                result = True
-        logger.debug('should_queue: %s (%s) from %s -> %s', link, rel,
-                     referrer, result)
-        return result
-
-    def _fetch(self):
-        """
-        Get a URL to fetch from the work queue, get the HTML page, examine its
-        links for download candidates and candidates for further scraping.
-
-        This is a handy method to run in a thread.
-        """
-        while True:
-            url = self._to_fetch.get()
-            try:
-                if url:
-                    page = self.get_page(url)
-                    if page is None:    # e.g. after an error
-                        continue
-                    for link, rel in page.links:
-                        if link not in self._seen:
-                            try:
-                                self._seen.add(link)
-                                if (not self._process_download(link) and
-                                    self._should_queue(link, url, rel)):
-                                    logger.debug('Queueing %s from %s', link, url)
-                                    self._to_fetch.put(link)
-                            except MetadataInvalidError:  # e.g. invalid versions
-                                pass
-            except Exception as e:  # pragma: no cover
-                self.errors.put(text_type(e))
-            finally:
-                # always do this, to avoid hangs :-)
-                self._to_fetch.task_done()
-            if not url:
-                #logger.debug('Sentinel seen, quitting.')
-                break
-
-    def get_page(self, url):
-        """
-        Get the HTML for an URL, possibly from an in-memory cache.
-
-        XXX TODO Note: this cache is never actually cleared. It's assumed that
-        the data won't get stale over the lifetime of a locator instance (not
-        necessarily true for the default_locator).
-        """
-        # http://peak.telecommunity.com/DevCenter/EasyInstall#package-index-api
-        scheme, netloc, path, _, _, _ = urlparse(url)
-        if scheme == 'file' and os.path.isdir(url2pathname(path)):
-            url = urljoin(ensure_slash(url), 'index.html')
-
-        if url in self._page_cache:
-            result = self._page_cache[url]
-            logger.debug('Returning %s from cache: %s', url, result)
-        else:
-            host = netloc.split(':', 1)[0]
-            result = None
-            if host in self._bad_hosts:
-                logger.debug('Skipping %s due to bad host %s', url, host)
-            else:
-                req = Request(url, headers={'Accept-encoding': 'identity'})
-                try:
-                    logger.debug('Fetching %s', url)
-                    resp = self.opener.open(req, timeout=self.timeout)
-                    logger.debug('Fetched %s', url)
-                    headers = resp.info()
-                    content_type = headers.get('Content-Type', '')
-                    if HTML_CONTENT_TYPE.match(content_type):
-                        final_url = resp.geturl()
-                        data = resp.read()
-                        encoding = headers.get('Content-Encoding')
-                        if encoding:
-                            decoder = self.decoders[encoding]   # fail if not found
-                            data = decoder(data)
-                        encoding = 'utf-8'
-                        m = CHARSET.search(content_type)
-                        if m:
-                            encoding = m.group(1)
-                        try:
-                            data = data.decode(encoding)
-                        except UnicodeError:  # pragma: no cover
-                            data = data.decode('latin-1')    # fallback
-                        result = Page(data, final_url)
-                        self._page_cache[final_url] = result
-                except HTTPError as e:
-                    if e.code != 404:
-                        logger.exception('Fetch failed: %s: %s', url, e)
-                except URLError as e:  # pragma: no cover
-                    logger.exception('Fetch failed: %s: %s', url, e)
-                    with self._lock:
-                        self._bad_hosts.add(host)
-                except Exception as e:  # pragma: no cover
-                    logger.exception('Fetch failed: %s: %s', url, e)
-                finally:
-                    self._page_cache[url] = result   # even if None (failure)
-        return result
-
-    _distname_re = re.compile('<a href=[^>]*>([^<]+)<')
-
-    def get_distribution_names(self):
-        """
-        Return all the distribution names known to this locator.
-        """
-        result = set()
-        page = self.get_page(self.base_url)
-        if not page:
-            raise DistlibException('Unable to get %s' % self.base_url)
-        for match in self._distname_re.finditer(page.data):
-            result.add(match.group(1))
-        return result
-
-class DirectoryLocator(Locator):
-    """
-    This class locates distributions in a directory tree.
-    """
-
-    def __init__(self, path, **kwargs):
-        """
-        Initialise an instance.
-        :param path: The root of the directory tree to search.
-        :param kwargs: Passed to the superclass constructor,
-                       except for:
-                       * recursive - if True (the default), subdirectories are
-                         recursed into. If False, only the top-level directory
-                         is searched,
-        """
-        self.recursive = kwargs.pop('recursive', True)
-        super(DirectoryLocator, self).__init__(**kwargs)
-        path = os.path.abspath(path)
-        if not os.path.isdir(path):  # pragma: no cover
-            raise DistlibException('Not a directory: %r' % path)
-        self.base_dir = path
-
-    def should_include(self, filename, parent):
-        """
-        Should a filename be considered as a candidate for a distribution
-        archive? As well as the filename, the directory which contains it
-        is provided, though not used by the current implementation.
-        """
-        return filename.endswith(self.downloadable_extensions)
-
-    def _get_project(self, name):
-        result = {'urls': {}, 'digests': {}}
-        for root, dirs, files in os.walk(self.base_dir):
-            for fn in files:
-                if self.should_include(fn, root):
-                    fn = os.path.join(root, fn)
-                    url = urlunparse(('file', '',
-                                      pathname2url(os.path.abspath(fn)),
-                                      '', '', ''))
-                    info = self.convert_url_to_download_info(url, name)
-                    if info:
-                        self._update_version_data(result, info)
-            if not self.recursive:
-                break
-        return result
-
-    def get_distribution_names(self):
-        """
-        Return all the distribution names known to this locator.
-        """
-        result = set()
-        for root, dirs, files in os.walk(self.base_dir):
-            for fn in files:
-                if self.should_include(fn, root):
-                    fn = os.path.join(root, fn)
-                    url = urlunparse(('file', '',
-                                      pathname2url(os.path.abspath(fn)),
-                                      '', '', ''))
-                    info = self.convert_url_to_download_info(url, None)
-                    if info:
-                        result.add(info['name'])
-            if not self.recursive:
-                break
-        return result
-
-class JSONLocator(Locator):
-    """
-    This locator uses special extended metadata (not available on PyPI) and is
-    the basis of performant dependency resolution in distlib. Other locators
-    require archive downloads before dependencies can be determined! As you
-    might imagine, that can be slow.
-    """
-    def get_distribution_names(self):
-        """
-        Return all the distribution names known to this locator.
-        """
-        raise NotImplementedError('Not available from this locator')
-
-    def _get_project(self, name):
-        result = {'urls': {}, 'digests': {}}
-        data = get_project_data(name)
-        if data:
-            for info in data.get('files', []):
-                if info['ptype'] != 'sdist' or info['pyversion'] != 'source':
-                    continue
-                # We don't store summary in project metadata as it makes
-                # the data bigger for no benefit during dependency
-                # resolution
-                dist = make_dist(data['name'], info['version'],
-                                 summary=data.get('summary',
-                                                  'Placeholder for summary'),
-                                 scheme=self.scheme)
-                md = dist.metadata
-                md.source_url = info['url']
-                # TODO SHA256 digest
-                if 'digest' in info and info['digest']:
-                    dist.digest = ('md5', info['digest'])
-                md.dependencies = info.get('requirements', {})
-                dist.exports = info.get('exports', {})
-                result[dist.version] = dist
-                result['urls'].setdefault(dist.version, set()).add(info['url'])
-        return result
-
-class DistPathLocator(Locator):
-    """
-    This locator finds installed distributions in a path. It can be useful for
-    adding to an :class:`AggregatingLocator`.
-    """
-    def __init__(self, distpath, **kwargs):
-        """
-        Initialise an instance.
-
-        :param distpath: A :class:`DistributionPath` instance to search.
-        """
-        super(DistPathLocator, self).__init__(**kwargs)
-        assert isinstance(distpath, DistributionPath)
-        self.distpath = distpath
-
-    def _get_project(self, name):
-        dist = self.distpath.get_distribution(name)
-        if dist is None:
-            result = {'urls': {}, 'digests': {}}
-        else:
-            result = {
-                dist.version: dist,
-                'urls': {dist.version: set([dist.source_url])},
-                'digests': {dist.version: set([None])}
-            }
-        return result
-
-
-class AggregatingLocator(Locator):
-    """
-    This class allows you to chain and/or merge a list of locators.
-    """
-    def __init__(self, *locators, **kwargs):
-        """
-        Initialise an instance.
-
-        :param locators: The list of locators to search.
-        :param kwargs: Passed to the superclass constructor,
-                       except for:
-                       * merge - if False (the default), the first successful
-                         search from any of the locators is returned. If True,
-                         the results from all locators are merged (this can be
-                         slow).
-        """
-        self.merge = kwargs.pop('merge', False)
-        self.locators = locators
-        super(AggregatingLocator, self).__init__(**kwargs)
-
-    def clear_cache(self):
-        super(AggregatingLocator, self).clear_cache()
-        for locator in self.locators:
-            locator.clear_cache()
-
-    def _set_scheme(self, value):
-        self._scheme = value
-        for locator in self.locators:
-            locator.scheme = value
-
-    scheme = property(Locator.scheme.fget, _set_scheme)
-
-    def _get_project(self, name):
-        result = {}
-        for locator in self.locators:
-            d = locator.get_project(name)
-            if d:
-                if self.merge:
-                    files = result.get('urls', {})
-                    digests = result.get('digests', {})
-                    # next line could overwrite result['urls'], result['digests']
-                    result.update(d)
-                    df = result.get('urls')
-                    if files and df:
-                        for k, v in files.items():
-                            if k in df:
-                                df[k] |= v
-                            else:
-                                df[k] = v
-                    dd = result.get('digests')
-                    if digests and dd:
-                        dd.update(digests)
-                else:
-                    # See issue #18. If any dists are found and we're looking
-                    # for specific constraints, we only return something if
-                    # a match is found. For example, if a DirectoryLocator
-                    # returns just foo (1.0) while we're looking for
-                    # foo (>= 2.0), we'll pretend there was nothing there so
-                    # that subsequent locators can be queried. Otherwise we
-                    # would just return foo (1.0) which would then lead to a
-                    # failure to find foo (>= 2.0), because other locators
-                    # weren't searched. Note that this only matters when
-                    # merge=False.
-                    if self.matcher is None:
-                        found = True
-                    else:
-                        found = False
-                        for k in d:
-                            if self.matcher.match(k):
-                                found = True
-                                break
-                    if found:
-                        result = d
-                        break
-        return result
-
-    def get_distribution_names(self):
-        """
-        Return all the distribution names known to this locator.
-        """
-        result = set()
-        for locator in self.locators:
-            try:
-                result |= locator.get_distribution_names()
-            except NotImplementedError:
-                pass
-        return result
-
-
-# We use a legacy scheme simply because most of the dists on PyPI use legacy
-# versions which don't conform to PEP 440.
-default_locator = AggregatingLocator(
-                    # JSONLocator(), # don't use as PEP 426 is withdrawn
-                    SimpleScrapingLocator('https://pypi.org/simple/',
-                                          timeout=3.0),
-                    scheme='legacy')
-
-locate = default_locator.locate
-
-
-class DependencyFinder(object):
-    """
-    Locate dependencies for distributions.
-    """
-
-    def __init__(self, locator=None):
-        """
-        Initialise an instance, using the specified locator
-        to locate distributions.
-        """
-        self.locator = locator or default_locator
-        self.scheme = get_scheme(self.locator.scheme)
-
-    def add_distribution(self, dist):
-        """
-        Add a distribution to the finder. This will update internal information
-        about who provides what.
-        :param dist: The distribution to add.
-        """
-        logger.debug('adding distribution %s', dist)
-        name = dist.key
-        self.dists_by_name[name] = dist
-        self.dists[(name, dist.version)] = dist
-        for p in dist.provides:
-            name, version = parse_name_and_version(p)
-            logger.debug('Add to provided: %s, %s, %s', name, version, dist)
-            self.provided.setdefault(name, set()).add((version, dist))
-
-    def remove_distribution(self, dist):
-        """
-        Remove a distribution from the finder. This will update internal
-        information about who provides what.
-        :param dist: The distribution to remove.
-        """
-        logger.debug('removing distribution %s', dist)
-        name = dist.key
-        del self.dists_by_name[name]
-        del self.dists[(name, dist.version)]
-        for p in dist.provides:
-            name, version = parse_name_and_version(p)
-            logger.debug('Remove from provided: %s, %s, %s', name, version, dist)
-            s = self.provided[name]
-            s.remove((version, dist))
-            if not s:
-                del self.provided[name]
-
-    def get_matcher(self, reqt):
-        """
-        Get a version matcher for a requirement.
-        :param reqt: The requirement
-        :type reqt: str
-        :return: A version matcher (an instance of
-                 :class:`distlib.version.Matcher`).
-        """
-        try:
-            matcher = self.scheme.matcher(reqt)
-        except UnsupportedVersionError:  # pragma: no cover
-            # XXX compat-mode if cannot read the version
-            name = reqt.split()[0]
-            matcher = self.scheme.matcher(name)
-        return matcher
-
-    def find_providers(self, reqt):
-        """
-        Find the distributions which can fulfill a requirement.
-
-        :param reqt: The requirement.
-         :type reqt: str
-        :return: A set of distribution which can fulfill the requirement.
-        """
-        matcher = self.get_matcher(reqt)
-        name = matcher.key   # case-insensitive
-        result = set()
-        provided = self.provided
-        if name in provided:
-            for version, provider in provided[name]:
-                try:
-                    match = matcher.match(version)
-                except UnsupportedVersionError:
-                    match = False
-
-                if match:
-                    result.add(provider)
-                    break
-        return result
-
-    def try_to_replace(self, provider, other, problems):
-        """
-        Attempt to replace one provider with another. This is typically used
-        when resolving dependencies from multiple sources, e.g. A requires
-        (B >= 1.0) while C requires (B >= 1.1).
-
-        For successful replacement, ``provider`` must meet all the requirements
-        which ``other`` fulfills.
-
-        :param provider: The provider we are trying to replace with.
-        :param other: The provider we're trying to replace.
-        :param problems: If False is returned, this will contain what
-                         problems prevented replacement. This is currently
-                         a tuple of the literal string 'cantreplace',
-                         ``provider``, ``other``  and the set of requirements
-                         that ``provider`` couldn't fulfill.
-        :return: True if we can replace ``other`` with ``provider``, else
-                 False.
-        """
-        rlist = self.reqts[other]
-        unmatched = set()
-        for s in rlist:
-            matcher = self.get_matcher(s)
-            if not matcher.match(provider.version):
-                unmatched.add(s)
-        if unmatched:
-            # can't replace other with provider
-            problems.add(('cantreplace', provider, other,
-                          frozenset(unmatched)))
-            result = False
-        else:
-            # can replace other with provider
-            self.remove_distribution(other)
-            del self.reqts[other]
-            for s in rlist:
-                self.reqts.setdefault(provider, set()).add(s)
-            self.add_distribution(provider)
-            result = True
-        return result
-
-    def find(self, requirement, meta_extras=None, prereleases=False):
-        """
-        Find a distribution and all distributions it depends on.
-
-        :param requirement: The requirement specifying the distribution to
-                            find, or a Distribution instance.
-        :param meta_extras: A list of meta extras such as :test:, :build: and
-                            so on.
-        :param prereleases: If ``True``, allow pre-release versions to be
-                            returned - otherwise, don't return prereleases
-                            unless they're all that's available.
-
-        Return a set of :class:`Distribution` instances and a set of
-        problems.
-
-        The distributions returned should be such that they have the
-        :attr:`required` attribute set to ``True`` if they were
-        from the ``requirement`` passed to ``find()``, and they have the
-        :attr:`build_time_dependency` attribute set to ``True`` unless they
-        are post-installation dependencies of the ``requirement``.
-
-        The problems should be a tuple consisting of the string
-        ``'unsatisfied'`` and the requirement which couldn't be satisfied
-        by any distribution known to the locator.
-        """
-
-        self.provided = {}
-        self.dists = {}
-        self.dists_by_name = {}
-        self.reqts = {}
-
-        meta_extras = set(meta_extras or [])
-        if ':*:' in meta_extras:
-            meta_extras.remove(':*:')
-            # :meta: and :run: are implicitly included
-            meta_extras |= set([':test:', ':build:', ':dev:'])
-
-        if isinstance(requirement, Distribution):
-            dist = odist = requirement
-            logger.debug('passed %s as requirement', odist)
-        else:
-            dist = odist = self.locator.locate(requirement,
-                                               prereleases=prereleases)
-            if dist is None:
-                raise DistlibException('Unable to locate %r' % requirement)
-            logger.debug('located %s', odist)
-        dist.requested = True
-        problems = set()
-        todo = set([dist])
-        install_dists = set([odist])
-        while todo:
-            dist = todo.pop()
-            name = dist.key     # case-insensitive
-            if name not in self.dists_by_name:
-                self.add_distribution(dist)
-            else:
-                #import pdb; pdb.set_trace()
-                other = self.dists_by_name[name]
-                if other != dist:
-                    self.try_to_replace(dist, other, problems)
-
-            ireqts = dist.run_requires | dist.meta_requires
-            sreqts = dist.build_requires
-            ereqts = set()
-            if meta_extras and dist in install_dists:
-                for key in ('test', 'build', 'dev'):
-                    e = ':%s:' % key
-                    if e in meta_extras:
-                        ereqts |= getattr(dist, '%s_requires' % key)
-            all_reqts = ireqts | sreqts | ereqts
-            for r in all_reqts:
-                providers = self.find_providers(r)
-                if not providers:
-                    logger.debug('No providers found for %r', r)
-                    provider = self.locator.locate(r, prereleases=prereleases)
-                    # If no provider is found and we didn't consider
-                    # prereleases, consider them now.
-                    if provider is None and not prereleases:
-                        provider = self.locator.locate(r, prereleases=True)
-                    if provider is None:
-                        logger.debug('Cannot satisfy %r', r)
-                        problems.add(('unsatisfied', r))
-                    else:
-                        n, v = provider.key, provider.version
-                        if (n, v) not in self.dists:
-                            todo.add(provider)
-                        providers.add(provider)
-                        if r in ireqts and dist in install_dists:
-                            install_dists.add(provider)
-                            logger.debug('Adding %s to install_dists',
-                                         provider.name_and_version)
-                for p in providers:
-                    name = p.key
-                    if name not in self.dists_by_name:
-                        self.reqts.setdefault(p, set()).add(r)
-                    else:
-                        other = self.dists_by_name[name]
-                        if other != p:
-                            # see if other can be replaced by p
-                            self.try_to_replace(p, other, problems)
-
-        dists = set(self.dists.values())
-        for dist in dists:
-            dist.build_time_dependency = dist not in install_dists
-            if dist.build_time_dependency:
-                logger.debug('%s is a build-time dependency only.',
-                             dist.name_and_version)
-        logger.debug('find done for %s', odist)
-        return dists, problems
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/setuptools/_vendor/packaging/_musllinux.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/setuptools/_vendor/packaging/_musllinux.py
deleted file mode 100644
index 706ba600a93c1b72594d96d3026daaa1998935b6..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/setuptools/_vendor/packaging/_musllinux.py
+++ /dev/null
@@ -1,80 +0,0 @@
-"""PEP 656 support.
-
-This module implements logic to detect if the currently running Python is
-linked against musl, and what musl version is used.
-"""
-
-import functools
-import re
-import subprocess
-import sys
-from typing import Iterator, NamedTuple, Optional
-
-from ._elffile import ELFFile
-
-
-class _MuslVersion(NamedTuple):
-    major: int
-    minor: int
-
-
-def _parse_musl_version(output: str) -> Optional[_MuslVersion]:
-    lines = [n for n in (n.strip() for n in output.splitlines()) if n]
-    if len(lines) < 2 or lines[0][:4] != "musl":
-        return None
-    m = re.match(r"Version (\d+)\.(\d+)", lines[1])
-    if not m:
-        return None
-    return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2)))
-
-
-@functools.lru_cache()
-def _get_musl_version(executable: str) -> Optional[_MuslVersion]:
-    """Detect currently-running musl runtime version.
-
-    This is done by checking the specified executable's dynamic linking
-    information, and invoking the loader to parse its output for a version
-    string. If the loader is musl, the output would be something like::
-
-        musl libc (x86_64)
-        Version 1.2.2
-        Dynamic Program Loader
-    """
-    try:
-        with open(executable, "rb") as f:
-            ld = ELFFile(f).interpreter
-    except (OSError, TypeError, ValueError):
-        return None
-    if ld is None or "musl" not in ld:
-        return None
-    proc = subprocess.run([ld], stderr=subprocess.PIPE, universal_newlines=True)
-    return _parse_musl_version(proc.stderr)
-
-
-def platform_tags(arch: str) -> Iterator[str]:
-    """Generate musllinux tags compatible to the current platform.
-
-    :param arch: Should be the part of platform tag after the ``linux_``
-        prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a
-        prerequisite for the current platform to be musllinux-compatible.
-
-    :returns: An iterator of compatible musllinux tags.
-    """
-    sys_musl = _get_musl_version(sys.executable)
-    if sys_musl is None:  # Python not dynamically linked against musl.
-        return
-    for minor in range(sys_musl.minor, -1, -1):
-        yield f"musllinux_{sys_musl.major}_{minor}_{arch}"
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sysconfig
-
-    plat = sysconfig.get_platform()
-    assert plat.startswith("linux-"), "not linux"
-
-    print("plat:", plat)
-    print("musl:", _get_musl_version(sys.executable))
-    print("tags:", end=" ")
-    for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])):
-        print(t, end="\n      ")
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/modeling/test_time_augmentation.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/modeling/test_time_augmentation.py
deleted file mode 100644
index 373e6bf00a39c040ff1da49d6dcd39a54a0b69a7..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/modeling/test_time_augmentation.py
+++ /dev/null
@@ -1,307 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import copy
-import numpy as np
-from contextlib import contextmanager
-from itertools import count
-from typing import List
-import torch
-from fvcore.transforms import HFlipTransform, NoOpTransform
-from torch import nn
-from torch.nn.parallel import DistributedDataParallel
-
-from detectron2.config import configurable
-from detectron2.data.detection_utils import read_image
-from detectron2.data.transforms import (
-    RandomFlip,
-    ResizeShortestEdge,
-    ResizeTransform,
-    apply_augmentations,
-)
-from detectron2.structures import Boxes, Instances
-
-from .meta_arch import GeneralizedRCNN
-from .postprocessing import detector_postprocess
-from .roi_heads.fast_rcnn import fast_rcnn_inference_single_image
-
-__all__ = ["DatasetMapperTTA", "GeneralizedRCNNWithTTA"]
-
-
-class DatasetMapperTTA:
-    """
-    Implement test-time augmentation for detection data.
-    It is a callable which takes a dataset dict from a detection dataset,
-    and returns a list of dataset dicts where the images
-    are augmented from the input image by the transformations defined in the config.
-    This is used for test-time augmentation.
-    """
-
-    @configurable
-    def __init__(self, min_sizes: List[int], max_size: int, flip: bool):
-        """
-        Args:
-            min_sizes: list of short-edge size to resize the image to
-            max_size: maximum height or width of resized images
-            flip: whether to apply flipping augmentation
-        """
-        self.min_sizes = min_sizes
-        self.max_size = max_size
-        self.flip = flip
-
-    @classmethod
-    def from_config(cls, cfg):
-        return {
-            "min_sizes": cfg.TEST.AUG.MIN_SIZES,
-            "max_size": cfg.TEST.AUG.MAX_SIZE,
-            "flip": cfg.TEST.AUG.FLIP,
-        }
-
-    def __call__(self, dataset_dict):
-        """
-        Args:
-            dict: a dict in standard model input format. See tutorials for details.
-
-        Returns:
-            list[dict]:
-                a list of dicts, which contain augmented version of the input image.
-                The total number of dicts is ``len(min_sizes) * (2 if flip else 1)``.
-                Each dict has field "transforms" which is a TransformList,
-                containing the transforms that are used to generate this image.
-        """
-        numpy_image = dataset_dict["image"].permute(1, 2, 0).numpy()
-        shape = numpy_image.shape
-        orig_shape = (dataset_dict["height"], dataset_dict["width"])
-        if shape[:2] != orig_shape:
-            # It transforms the "original" image in the dataset to the input image
-            pre_tfm = ResizeTransform(orig_shape[0], orig_shape[1], shape[0], shape[1])
-        else:
-            pre_tfm = NoOpTransform()
-
-        # Create all combinations of augmentations to use
-        aug_candidates = []  # each element is a list[Augmentation]
-        for min_size in self.min_sizes:
-            resize = ResizeShortestEdge(min_size, self.max_size)
-            aug_candidates.append([resize])  # resize only
-            if self.flip:
-                flip = RandomFlip(prob=1.0)
-                aug_candidates.append([resize, flip])  # resize + flip
-
-        # Apply all the augmentations
-        ret = []
-        for aug in aug_candidates:
-            new_image, tfms = apply_augmentations(aug, np.copy(numpy_image))
-            torch_image = torch.from_numpy(np.ascontiguousarray(new_image.transpose(2, 0, 1)))
-
-            dic = copy.deepcopy(dataset_dict)
-            dic["transforms"] = pre_tfm + tfms
-            dic["image"] = torch_image
-            ret.append(dic)
-        return ret
-
-
-class GeneralizedRCNNWithTTA(nn.Module):
-    """
-    A GeneralizedRCNN with test-time augmentation enabled.
-    Its :meth:`__call__` method has the same interface as :meth:`GeneralizedRCNN.forward`.
-    """
-
-    def __init__(self, cfg, model, tta_mapper=None, batch_size=3):
-        """
-        Args:
-            cfg (CfgNode):
-            model (GeneralizedRCNN): a GeneralizedRCNN to apply TTA on.
-            tta_mapper (callable): takes a dataset dict and returns a list of
-                augmented versions of the dataset dict. Defaults to
-                `DatasetMapperTTA(cfg)`.
-            batch_size (int): batch the augmented images into this batch size for inference.
-        """
-        super().__init__()
-        if isinstance(model, DistributedDataParallel):
-            model = model.module
-        assert isinstance(
-            model, GeneralizedRCNN
-        ), "TTA is only supported on GeneralizedRCNN. Got a model of type {}".format(type(model))
-        self.cfg = cfg.clone()
-        assert not self.cfg.MODEL.KEYPOINT_ON, "TTA for keypoint is not supported yet"
-        assert (
-            not self.cfg.MODEL.LOAD_PROPOSALS
-        ), "TTA for pre-computed proposals is not supported yet"
-
-        self.model = model
-
-        if tta_mapper is None:
-            tta_mapper = DatasetMapperTTA(cfg)
-        self.tta_mapper = tta_mapper
-        self.batch_size = batch_size
-
-    @contextmanager
-    def _turn_off_roi_heads(self, attrs):
-        """
-        Open a context where some heads in `model.roi_heads` are temporarily turned off.
-        Args:
-            attr (list[str]): the attribute in `model.roi_heads` which can be used
-                to turn off a specific head, e.g., "mask_on", "keypoint_on".
-        """
-        roi_heads = self.model.roi_heads
-        old = {}
-        for attr in attrs:
-            try:
-                old[attr] = getattr(roi_heads, attr)
-            except AttributeError:
-                # The head may not be implemented in certain ROIHeads
-                pass
-
-        if len(old.keys()) == 0:
-            yield
-        else:
-            for attr in old.keys():
-                setattr(roi_heads, attr, False)
-            yield
-            for attr in old.keys():
-                setattr(roi_heads, attr, old[attr])
-
-    def _batch_inference(self, batched_inputs, detected_instances=None):
-        """
-        Execute inference on a list of inputs,
-        using batch size = self.batch_size, instead of the length of the list.
-
-        Inputs & outputs have the same format as :meth:`GeneralizedRCNN.inference`
-        """
-        if detected_instances is None:
-            detected_instances = [None] * len(batched_inputs)
-
-        outputs = []
-        inputs, instances = [], []
-        for idx, input, instance in zip(count(), batched_inputs, detected_instances):
-            inputs.append(input)
-            instances.append(instance)
-            if len(inputs) == self.batch_size or idx == len(batched_inputs) - 1:
-                outputs.extend(
-                    self.model.inference(
-                        inputs,
-                        instances if instances[0] is not None else None,
-                        do_postprocess=False,
-                    )
-                )
-                inputs, instances = [], []
-        return outputs
-
-    def __call__(self, batched_inputs):
-        """
-        Same input/output format as :meth:`GeneralizedRCNN.forward`
-        """
-
-        def _maybe_read_image(dataset_dict):
-            ret = copy.copy(dataset_dict)
-            if "image" not in ret:
-                image = read_image(ret.pop("file_name"), self.model.input_format)
-                image = torch.from_numpy(np.ascontiguousarray(image.transpose(2, 0, 1)))  # CHW
-                ret["image"] = image
-            if "height" not in ret and "width" not in ret:
-                ret["height"] = image.shape[1]
-                ret["width"] = image.shape[2]
-            return ret
-
-        return [self._inference_one_image(_maybe_read_image(x)) for x in batched_inputs]
-
-    def _inference_one_image(self, input):
-        """
-        Args:
-            input (dict): one dataset dict with "image" field being a CHW tensor
-
-        Returns:
-            dict: one output dict
-        """
-        orig_shape = (input["height"], input["width"])
-        augmented_inputs, tfms = self._get_augmented_inputs(input)
-        # Detect boxes from all augmented versions
-        with self._turn_off_roi_heads(["mask_on", "keypoint_on"]):
-            # temporarily disable roi heads
-            all_boxes, all_scores, all_classes = self._get_augmented_boxes(augmented_inputs, tfms)
-        # merge all detected boxes to obtain final predictions for boxes
-        merged_instances = self._merge_detections(all_boxes, all_scores, all_classes, orig_shape)
-
-        if self.cfg.MODEL.MASK_ON:
-            # Use the detected boxes to obtain masks
-            augmented_instances = self._rescale_detected_boxes(
-                augmented_inputs, merged_instances, tfms
-            )
-            # run forward on the detected boxes
-            outputs = self._batch_inference(augmented_inputs, augmented_instances)
-            # Delete now useless variables to avoid being out of memory
-            del augmented_inputs, augmented_instances
-            # average the predictions
-            merged_instances.pred_masks = self._reduce_pred_masks(outputs, tfms)
-            merged_instances = detector_postprocess(merged_instances, *orig_shape)
-            return {"instances": merged_instances}
-        else:
-            return {"instances": merged_instances}
-
-    def _get_augmented_inputs(self, input):
-        augmented_inputs = self.tta_mapper(input)
-        tfms = [x.pop("transforms") for x in augmented_inputs]
-        return augmented_inputs, tfms
-
-    def _get_augmented_boxes(self, augmented_inputs, tfms):
-        # 1: forward with all augmented images
-        outputs = self._batch_inference(augmented_inputs)
-        # 2: union the results
-        all_boxes = []
-        all_scores = []
-        all_classes = []
-        for output, tfm in zip(outputs, tfms):
-            # Need to inverse the transforms on boxes, to obtain results on original image
-            pred_boxes = output.pred_boxes.tensor
-            original_pred_boxes = tfm.inverse().apply_box(pred_boxes.cpu().numpy())
-            all_boxes.append(torch.from_numpy(original_pred_boxes).to(pred_boxes.device))
-
-            all_scores.extend(output.scores)
-            all_classes.extend(output.pred_classes)
-        all_boxes = torch.cat(all_boxes, dim=0)
-        return all_boxes, all_scores, all_classes
-
-    def _merge_detections(self, all_boxes, all_scores, all_classes, shape_hw):
-        # select from the union of all results
-        num_boxes = len(all_boxes)
-        num_classes = self.cfg.MODEL.ROI_HEADS.NUM_CLASSES
-        # +1 because fast_rcnn_inference expects background scores as well
-        all_scores_2d = torch.zeros(num_boxes, num_classes + 1, device=all_boxes.device)
-        for idx, cls, score in zip(count(), all_classes, all_scores):
-            all_scores_2d[idx, cls] = score
-
-        merged_instances, _ = fast_rcnn_inference_single_image(
-            all_boxes,
-            all_scores_2d,
-            shape_hw,
-            1e-8,
-            self.cfg.MODEL.ROI_HEADS.NMS_THRESH_TEST,
-            self.cfg.TEST.DETECTIONS_PER_IMAGE,
-        )
-
-        return merged_instances
-
-    def _rescale_detected_boxes(self, augmented_inputs, merged_instances, tfms):
-        augmented_instances = []
-        for input, tfm in zip(augmented_inputs, tfms):
-            # Transform the target box to the augmented image's coordinate space
-            pred_boxes = merged_instances.pred_boxes.tensor.cpu().numpy()
-            pred_boxes = torch.from_numpy(tfm.apply_box(pred_boxes))
-
-            aug_instances = Instances(
-                image_size=input["image"].shape[1:3],
-                pred_boxes=Boxes(pred_boxes),
-                pred_classes=merged_instances.pred_classes,
-                scores=merged_instances.scores,
-            )
-            augmented_instances.append(aug_instances)
-        return augmented_instances
-
-    def _reduce_pred_masks(self, outputs, tfms):
-        # Should apply inverse transforms on masks.
-        # We assume only resize & flip are used. pred_masks is a scale-invariant
-        # representation, so we handle flip specially
-        for output, tfm in zip(outputs, tfms):
-            if any(isinstance(t, HFlipTransform) for t in tfm.transforms):
-                output.pred_masks = output.pred_masks.flip(dims=[3])
-        all_pred_masks = torch.stack([o.pred_masks for o in outputs], dim=0)
-        avg_pred_masks = torch.mean(all_pred_masks, dim=0)
-        return avg_pred_masks
diff --git a/spaces/Theivaprakasham/yolov6/tools/quantization/tensorrt/post_training/onnx_to_tensorrt.py b/spaces/Theivaprakasham/yolov6/tools/quantization/tensorrt/post_training/onnx_to_tensorrt.py
deleted file mode 100644
index 4e52d401a3a9da6723a19c63e812d18b6884f38f..0000000000000000000000000000000000000000
--- a/spaces/Theivaprakasham/yolov6/tools/quantization/tensorrt/post_training/onnx_to_tensorrt.py
+++ /dev/null
@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-
-#
-# Modified by Meituan
-# 2022.6.24
-# 
-
-# Copyright 2019 NVIDIA Corporation
-#
-# 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
-import sys
-import glob
-import math
-import logging
-import argparse
-
-import tensorrt as trt
-#sys.path.remove('/opt/ros/kinetic/lib/python2.7/dist-packages')
-
-TRT_LOGGER = trt.Logger()
-logging.basicConfig(level=logging.DEBUG,
-                    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-                    datefmt="%Y-%m-%d %H:%M:%S")
-logger = logging.getLogger(__name__)
-
-
-def add_profiles(config, inputs, opt_profiles):
-    logger.debug("=== Optimization Profiles ===")
-    for i, profile in enumerate(opt_profiles):
-        for inp in inputs:
-            _min, _opt, _max = profile.get_shape(inp.name)
-            logger.debug("{} - OptProfile {} - Min {} Opt {} Max {}".format(inp.name, i, _min, _opt, _max))
-        config.add_optimization_profile(profile)
-
-
-def mark_outputs(network):
-    # Mark last layer's outputs if not already marked
-    # NOTE: This may not be correct in all cases
-    last_layer = network.get_layer(network.num_layers-1)
-    if not last_layer.num_outputs:
-        logger.error("Last layer contains no outputs.")
-        return
-
-    for i in range(last_layer.num_outputs):
-        network.mark_output(last_layer.get_output(i))
-
-
-def check_network(network):
-    if not network.num_outputs:
-        logger.warning("No output nodes found, marking last layer's outputs as network outputs. Correct this if wrong.")
-        mark_outputs(network)
-    
-    inputs = [network.get_input(i) for i in range(network.num_inputs)]
-    outputs = [network.get_output(i) for i in range(network.num_outputs)]
-    max_len = max([len(inp.name) for inp in inputs] + [len(out.name) for out in outputs])
-
-    logger.debug("=== Network Description ===")
-    for i, inp in enumerate(inputs):
-        logger.debug("Input  {0} | Name: {1:{2}} | Shape: {3}".format(i, inp.name, max_len, inp.shape))
-    for i, out in enumerate(outputs):
-        logger.debug("Output {0} | Name: {1:{2}} | Shape: {3}".format(i, out.name, max_len, out.shape))
-
-
-def get_batch_sizes(max_batch_size):
-    # Returns powers of 2, up to and including max_batch_size
-    max_exponent = math.log2(max_batch_size)
-    for i in range(int(max_exponent)+1):
-        batch_size = 2**i
-        yield batch_size
-    
-    if max_batch_size != batch_size:
-        yield max_batch_size
-
-
-# TODO: This only covers dynamic shape for batch size, not dynamic shape for other dimensions
-def create_optimization_profiles(builder, inputs, batch_sizes=[1,8,16,32,64]): 
-    # Check if all inputs are fixed explicit batch to create a single profile and avoid duplicates
-    if all([inp.shape[0] > -1 for inp in inputs]):
-        profile = builder.create_optimization_profile()
-        for inp in inputs:
-            fbs, shape = inp.shape[0], inp.shape[1:]
-            profile.set_shape(inp.name, min=(fbs, *shape), opt=(fbs, *shape), max=(fbs, *shape))
-            return [profile]
-    
-    # Otherwise for mixed fixed+dynamic explicit batch inputs, create several profiles
-    profiles = {}
-    for bs in batch_sizes:
-        if not profiles.get(bs):
-            profiles[bs] = builder.create_optimization_profile()
-
-        for inp in inputs: 
-            shape = inp.shape[1:]
-            # Check if fixed explicit batch
-            if inp.shape[0] > -1:
-                bs = inp.shape[0]
-
-            profiles[bs].set_shape(inp.name, min=(bs, *shape), opt=(bs, *shape), max=(bs, *shape))
-
-    return list(profiles.values())
-
-def main():
-    parser = argparse.ArgumentParser(description="Creates a TensorRT engine from the provided ONNX file.\n")
-    parser.add_argument("--onnx", required=True, help="The ONNX model file to convert to TensorRT")
-    parser.add_argument("-o", "--output", type=str, default="model.engine", help="The path at which to write the engine")
-    parser.add_argument("-b", "--max-batch-size", type=int, help="The max batch size for the TensorRT engine input")
-    parser.add_argument("-v", "--verbosity", action="count", help="Verbosity for logging. (None) for ERROR, (-v) for INFO/WARNING/ERROR, (-vv) for VERBOSE.")
-    parser.add_argument("--explicit-batch", action='store_true', help="Set trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH.")
-    parser.add_argument("--explicit-precision", action='store_true', help="Set trt.NetworkDefinitionCreationFlag.EXPLICIT_PRECISION.")
-    parser.add_argument("--gpu-fallback", action='store_true', help="Set trt.BuilderFlag.GPU_FALLBACK.")
-    parser.add_argument("--refittable", action='store_true', help="Set trt.BuilderFlag.REFIT.")
-    parser.add_argument("--debug", action='store_true', help="Set trt.BuilderFlag.DEBUG.")
-    parser.add_argument("--strict-types", action='store_true', help="Set trt.BuilderFlag.STRICT_TYPES.")
-    parser.add_argument("--fp16", action="store_true", help="Attempt to use FP16 kernels when possible.")
-    parser.add_argument("--int8", action="store_true", help="Attempt to use INT8 kernels when possible. This should generally be used in addition to the --fp16 flag. \
-                                                             ONLY SUPPORTS RESNET-LIKE MODELS SUCH AS RESNET50/VGG16/INCEPTION/etc.")
-    parser.add_argument("--calibration-cache", help="(INT8 ONLY) The path to read/write from calibration cache.", default="calibration.cache")
-    parser.add_argument("--calibration-data", help="(INT8 ONLY) The directory containing {*.jpg, *.jpeg, *.png} files to use for calibration. (ex: Imagenet Validation Set)", default=None)
-    parser.add_argument("--calibration-batch-size", help="(INT8 ONLY) The batch size to use during calibration.", type=int, default=128)
-    parser.add_argument("--max-calibration-size", help="(INT8 ONLY) The max number of data to calibrate on from --calibration-data.", type=int, default=2048)
-    parser.add_argument("-s", "--simple", action="store_true", help="Use SimpleCalibrator with random data instead of ImagenetCalibrator for INT8 calibration.")
-    args, _ = parser.parse_known_args()
-    
-    print(args)
-
-    # Adjust logging verbosity
-    if args.verbosity is None:
-        TRT_LOGGER.min_severity = trt.Logger.Severity.ERROR
-    # -v
-    elif args.verbosity == 1:
-        TRT_LOGGER.min_severity = trt.Logger.Severity.INFO
-    # -vv
-    else:
-        TRT_LOGGER.min_severity = trt.Logger.Severity.VERBOSE
-    logger.info("TRT_LOGGER Verbosity: {:}".format(TRT_LOGGER.min_severity))
-
-    # Network flags
-    network_flags = 0
-    if args.explicit_batch:
-        network_flags |= 1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
-    if args.explicit_precision:
-        network_flags |= 1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_PRECISION)
-
-    builder_flag_map = {
-            'gpu_fallback': trt.BuilderFlag.GPU_FALLBACK,
-            'refittable': trt.BuilderFlag.REFIT,
-            'debug': trt.BuilderFlag.DEBUG,
-            'strict_types': trt.BuilderFlag.STRICT_TYPES,
-            'fp16': trt.BuilderFlag.FP16,
-            'int8': trt.BuilderFlag.INT8,
-    }
-
-    # Building engine
-    with trt.Builder(TRT_LOGGER) as builder, \
-         builder.create_network(network_flags) as network, \
-         builder.create_builder_config() as config, \
-         trt.OnnxParser(network, TRT_LOGGER) as parser:
-            
-        config.max_workspace_size = 2**30 # 1GiB
-
-        # Set Builder Config Flags
-        for flag in builder_flag_map:
-            if getattr(args, flag):
-                logger.info("Setting {}".format(builder_flag_map[flag]))
-                config.set_flag(builder_flag_map[flag])
-
-        # Fill network atrributes with information by parsing model
-        with open(args.onnx, "rb") as f:
-            if not parser.parse(f.read()):
-                print('ERROR: Failed to parse the ONNX file: {}'.format(args.onnx))
-                for error in range(parser.num_errors):
-                    print(parser.get_error(error))
-                sys.exit(1)
-
-        # Display network info and check certain properties
-        check_network(network)
-
-        if args.explicit_batch:
-            # Add optimization profiles
-            batch_sizes = [1, 8, 16, 32, 64]
-            inputs = [network.get_input(i) for i in range(network.num_inputs)]
-            opt_profiles = create_optimization_profiles(builder, inputs, batch_sizes)
-            add_profiles(config, inputs, opt_profiles)
-        # Implicit Batch Network
-        else:
-            builder.max_batch_size = args.max_batch_size
-            opt_profiles = []
-
-        # Precision flags
-        if args.fp16 and not builder.platform_has_fast_fp16:
-            logger.warning("FP16 not supported on this platform.")
-
-        if args.int8 and not builder.platform_has_fast_int8:
-            logger.warning("INT8 not supported on this platform.")
-
-        if args.int8:
-                from Calibrator import ImageCalibrator, get_int8_calibrator # local module
-                config.int8_calibrator = get_int8_calibrator(args.calibration_cache,
-                                                             args.calibration_data,
-                                                             args.max_calibration_size,
-                                                             args.calibration_batch_size)
-
-        logger.info("Building Engine...")
-        with builder.build_engine(network, config) as engine, open(args.output, "wb") as f:
-            logger.info("Serializing engine to file: {:}".format(args.output))
-            f.write(engine.serialize())
-
-if __name__ == "__main__":
-    main()
diff --git a/spaces/Toaster496/HugChatWithPlugin/HuggingChatAPI.py b/spaces/Toaster496/HugChatWithPlugin/HuggingChatAPI.py
deleted file mode 100644
index 6c8f1a4ddbf33c1c420ffb2addfa770c7b70b8c9..0000000000000000000000000000000000000000
--- a/spaces/Toaster496/HugChatWithPlugin/HuggingChatAPI.py
+++ /dev/null
@@ -1,65 +0,0 @@
-
-from hugchat import hugchat
-from hugchat.login import Login
-from langchain.llms.base import LLM
-from typing import Optional, List, Mapping, Any
-from time import sleep
-
-
-# THIS IS A CUSTOM LLM WRAPPER Based on hugchat library
-# Reference :
-# - Langchain custom LLM wrapper : https://python.langchain.com/docs/modules/model_io/models/llms/how_to/custom_llm
-# - HugChat library : https://github.com/Soulter/hugging-chat-api
-
-class HuggingChat(LLM):
-    """HuggingChat LLM wrapper."""
-    chatbot : Optional[hugchat.ChatBot] = None
-    conversation : Optional[str] = ""
-    email : Optional[str]
-    psw : Optional[str]
-
-    
-    
-    @property
-    def _llm_type(self) -> str:
-        return "custom"
-
-    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
-        if stop is not None:
-            pass
-
-        if self.chatbot is None:
-            if self.email is None and self.psw is None:
-                ValueError("Email and Password is required, pls check the documentation on github : https://github.com/Soulter/hugging-chat-api")
-            else: 
-                if self.conversation == "":
-                    sign = Login(self.email, self.psw) # type: ignore
-                    cookies = sign.login()
-
-                    # Create a ChatBot
-                    self.chatbot = hugchat.ChatBot(cookies=cookies.get_dict()) 
-                
-                    id = self.chatbot.new_conversation()
-                    self.chatbot.change_conversation(id)
-                    self.conversation = id         
-                else:
-                    self.chatbot.change_conversation(self.conversation) # type: ignore
-            
-    
-        data = self.chatbot.chat(prompt, temperature=0.4, stream=False) # type: ignore
-        return data # type: ignore
-
-    @property
-    def _identifying_params(self) -> Mapping[str, Any]:
-        """Get the identifying parameters."""
-        return {"model": "HuggingCHAT"}
-
-
-
-#llm = HuggingChat(email = "YOUR-EMAIL" , psw = = "YOUR-PSW" ) #for start new chat
-
-
-#print(llm("Hello, how are you?"))
-#print(llm("what is AI?"))
-#print(llm("Can you resume your previus answer?")) #now memory work well
-
diff --git a/spaces/Ttss4422/Joeythemonster-anything-midjourney-v-4/README.md b/spaces/Ttss4422/Joeythemonster-anything-midjourney-v-4/README.md
deleted file mode 100644
index 663302668ad5ed643ac397d9e27506b78698e710..0000000000000000000000000000000000000000
--- a/spaces/Ttss4422/Joeythemonster-anything-midjourney-v-4/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Joeythemonster Anything Midjourney V 4
-emoji: 🔥
-colorFrom: indigo
-colorTo: pink
-sdk: gradio
-sdk_version: 3.35.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Usaki108/VoiceChange/infer_pack/models_onnx.py b/spaces/Usaki108/VoiceChange/infer_pack/models_onnx.py
deleted file mode 100644
index b945eac8e59aac38fbd166da49eda01e2b8f4bd4..0000000000000000000000000000000000000000
--- a/spaces/Usaki108/VoiceChange/infer_pack/models_onnx.py
+++ /dev/null
@@ -1,818 +0,0 @@
-import math, pdb, os
-from time import time as ttime
-import torch
-from torch import nn
-from torch.nn import functional as F
-from infer_pack import modules
-from infer_pack import attentions
-from infer_pack import commons
-from infer_pack.commons import init_weights, get_padding
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from infer_pack.commons import init_weights
-import numpy as np
-from infer_pack import commons
-
-
-class TextEncoder256(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(256, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        stats = self.proj(x) * x_mask
-
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        return m, logs, x_mask
-
-
-class TextEncoder768(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(768, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        stats = self.proj(x) * x_mask
-
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        return m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        n_flows=4,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.flows = nn.ModuleList()
-        for i in range(n_flows):
-            self.flows.append(
-                modules.ResidualCouplingLayer(
-                    channels,
-                    hidden_channels,
-                    kernel_size,
-                    dilation_rate,
-                    n_layers,
-                    gin_channels=gin_channels,
-                    mean_only=True,
-                )
-            )
-            self.flows.append(modules.Flip())
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        if not reverse:
-            for flow in self.flows:
-                x, _ = flow(x, x_mask, g=g, reverse=reverse)
-        else:
-            for flow in reversed(self.flows):
-                x = flow(x, x_mask, g=g, reverse=reverse)
-        return x
-
-    def remove_weight_norm(self):
-        for i in range(self.n_flows):
-            self.flows[i * 2].remove_weight_norm()
-
-
-class PosteriorEncoder(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.gin_channels = gin_channels
-
-        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-        self.enc = modules.WN(
-            hidden_channels,
-            kernel_size,
-            dilation_rate,
-            n_layers,
-            gin_channels=gin_channels,
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, x, x_lengths, g=None):
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.pre(x) * x_mask
-        x = self.enc(x, x_mask, g=g)
-        stats = self.proj(x) * x_mask
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
-        return z, m, logs, x_mask
-
-    def remove_weight_norm(self):
-        self.enc.remove_weight_norm()
-
-
-class Generator(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels=0,
-    ):
-        super(Generator, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-    def forward(self, x, g=None):
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-class SineGen(torch.nn.Module):
-    """Definition of sine generator
-    SineGen(samp_rate, harmonic_num = 0,
-            sine_amp = 0.1, noise_std = 0.003,
-            voiced_threshold = 0,
-            flag_for_pulse=False)
-    samp_rate: sampling rate in Hz
-    harmonic_num: number of harmonic overtones (default 0)
-    sine_amp: amplitude of sine-wavefrom (default 0.1)
-    noise_std: std of Gaussian noise (default 0.003)
-    voiced_thoreshold: F0 threshold for U/V classification (default 0)
-    flag_for_pulse: this SinGen is used inside PulseGen (default False)
-    Note: when flag_for_pulse is True, the first time step of a voiced
-        segment is always sin(np.pi) or cos(0)
-    """
-
-    def __init__(
-        self,
-        samp_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        noise_std=0.003,
-        voiced_threshold=0,
-        flag_for_pulse=False,
-    ):
-        super(SineGen, self).__init__()
-        self.sine_amp = sine_amp
-        self.noise_std = noise_std
-        self.harmonic_num = harmonic_num
-        self.dim = self.harmonic_num + 1
-        self.sampling_rate = samp_rate
-        self.voiced_threshold = voiced_threshold
-
-    def _f02uv(self, f0):
-        # generate uv signal
-        uv = torch.ones_like(f0)
-        uv = uv * (f0 > self.voiced_threshold)
-        return uv
-
-    def forward(self, f0, upp):
-        """sine_tensor, uv = forward(f0)
-        input F0: tensor(batchsize=1, length, dim=1)
-                  f0 for unvoiced steps should be 0
-        output sine_tensor: tensor(batchsize=1, length, dim)
-        output uv: tensor(batchsize=1, length, 1)
-        """
-        with torch.no_grad():
-            f0 = f0[:, None].transpose(1, 2)
-            f0_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim, device=f0.device)
-            # fundamental component
-            f0_buf[:, :, 0] = f0[:, :, 0]
-            for idx in np.arange(self.harmonic_num):
-                f0_buf[:, :, idx + 1] = f0_buf[:, :, 0] * (
-                    idx + 2
-                )  # idx + 2: the (idx+1)-th overtone, (idx+2)-th harmonic
-            rad_values = (f0_buf / self.sampling_rate) % 1  ###%1意味着n_har的乘积无法后处理优化
-            rand_ini = torch.rand(
-                f0_buf.shape[0], f0_buf.shape[2], device=f0_buf.device
-            )
-            rand_ini[:, 0] = 0
-            rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
-            tmp_over_one = torch.cumsum(rad_values, 1)  # % 1  #####%1意味着后面的cumsum无法再优化
-            tmp_over_one *= upp
-            tmp_over_one = F.interpolate(
-                tmp_over_one.transpose(2, 1),
-                scale_factor=upp,
-                mode="linear",
-                align_corners=True,
-            ).transpose(2, 1)
-            rad_values = F.interpolate(
-                rad_values.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(
-                2, 1
-            )  #######
-            tmp_over_one %= 1
-            tmp_over_one_idx = (tmp_over_one[:, 1:, :] - tmp_over_one[:, :-1, :]) < 0
-            cumsum_shift = torch.zeros_like(rad_values)
-            cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
-            sine_waves = torch.sin(
-                torch.cumsum(rad_values + cumsum_shift, dim=1) * 2 * np.pi
-            )
-            sine_waves = sine_waves * self.sine_amp
-            uv = self._f02uv(f0)
-            uv = F.interpolate(
-                uv.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(2, 1)
-            noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
-            noise = noise_amp * torch.randn_like(sine_waves)
-            sine_waves = sine_waves * uv + noise
-        return sine_waves, uv, noise
-
-
-class SourceModuleHnNSF(torch.nn.Module):
-    """SourceModule for hn-nsf
-    SourceModule(sampling_rate, harmonic_num=0, sine_amp=0.1,
-                 add_noise_std=0.003, voiced_threshod=0)
-    sampling_rate: sampling_rate in Hz
-    harmonic_num: number of harmonic above F0 (default: 0)
-    sine_amp: amplitude of sine source signal (default: 0.1)
-    add_noise_std: std of additive Gaussian noise (default: 0.003)
-        note that amplitude of noise in unvoiced is decided
-        by sine_amp
-    voiced_threshold: threhold to set U/V given F0 (default: 0)
-    Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
-    F0_sampled (batchsize, length, 1)
-    Sine_source (batchsize, length, 1)
-    noise_source (batchsize, length 1)
-    uv (batchsize, length, 1)
-    """
-
-    def __init__(
-        self,
-        sampling_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        add_noise_std=0.003,
-        voiced_threshod=0,
-        is_half=True,
-    ):
-        super(SourceModuleHnNSF, self).__init__()
-
-        self.sine_amp = sine_amp
-        self.noise_std = add_noise_std
-        self.is_half = is_half
-        # to produce sine waveforms
-        self.l_sin_gen = SineGen(
-            sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshod
-        )
-
-        # to merge source harmonics into a single excitation
-        self.l_linear = torch.nn.Linear(harmonic_num + 1, 1)
-        self.l_tanh = torch.nn.Tanh()
-
-    def forward(self, x, upp=None):
-        sine_wavs, uv, _ = self.l_sin_gen(x, upp)
-        if self.is_half:
-            sine_wavs = sine_wavs.half()
-        sine_merge = self.l_tanh(self.l_linear(sine_wavs))
-        return sine_merge, None, None  # noise, uv
-
-
-class GeneratorNSF(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels,
-        sr,
-        is_half=False,
-    ):
-        super(GeneratorNSF, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-
-        self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(upsample_rates))
-        self.m_source = SourceModuleHnNSF(
-            sampling_rate=sr, harmonic_num=0, is_half=is_half
-        )
-        self.noise_convs = nn.ModuleList()
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            c_cur = upsample_initial_channel // (2 ** (i + 1))
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-            if i + 1 < len(upsample_rates):
-                stride_f0 = np.prod(upsample_rates[i + 1 :])
-                self.noise_convs.append(
-                    Conv1d(
-                        1,
-                        c_cur,
-                        kernel_size=stride_f0 * 2,
-                        stride=stride_f0,
-                        padding=stride_f0 // 2,
-                    )
-                )
-            else:
-                self.noise_convs.append(Conv1d(1, c_cur, kernel_size=1))
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-        self.upp = np.prod(upsample_rates)
-
-    def forward(self, x, f0, g=None):
-        har_source, noi_source, uv = self.m_source(f0, self.upp)
-        har_source = har_source.transpose(1, 2)
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            x_source = self.noise_convs[i](har_source)
-            x = x + x_source
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-sr2sr = {
-    "32k": 32000,
-    "40k": 40000,
-    "48k": 48000,
-}
-
-
-class SynthesizerTrnMsNSFsidM(nn.Module):
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        gin_channels,
-        sr,
-        **kwargs
-    ):
-        super().__init__()
-        if type(sr) == type("strr"):
-            sr = sr2sr[sr]
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        if self.gin_channels == 256:
-            self.enc_p = TextEncoder256(
-                inter_channels,
-                hidden_channels,
-                filter_channels,
-                n_heads,
-                n_layers,
-                kernel_size,
-                p_dropout,
-            )
-        else:
-            self.enc_p = TextEncoder768(
-                inter_channels,
-                hidden_channels,
-                filter_channels,
-                n_heads,
-                n_layers,
-                kernel_size,
-                p_dropout,
-            )
-        self.dec = GeneratorNSF(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-            sr=sr,
-            is_half=kwargs["is_half"],
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        self.speaker_map = None
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def construct_spkmixmap(self, n_speaker):
-        self.speaker_map = torch.zeros((n_speaker, 1, 1, self.gin_channels))
-        for i in range(n_speaker):
-            self.speaker_map[i] = self.emb_g(torch.LongTensor([[i]]))
-        self.speaker_map = self.speaker_map.unsqueeze(0)
-
-    def forward(self, phone, phone_lengths, pitch, nsff0, g, rnd, max_len=None):
-        if self.speaker_map is not None:  # [N, S]  *  [S, B, 1, H]
-            g = g.reshape((g.shape[0], g.shape[1], 1, 1, 1))  # [N, S, B, 1, 1]
-            g = g * self.speaker_map  # [N, S, B, 1, H]
-            g = torch.sum(g, dim=1)  # [N, 1, B, 1, H]
-            g = g.transpose(0, -1).transpose(0, -2).squeeze(0)  # [B, H, N]
-        else:
-            g = g.unsqueeze(0)
-            g = self.emb_g(g).transpose(1, 2)
-
-        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        z_p = (m_p + torch.exp(logs_p) * rnd) * x_mask
-        z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec((z * x_mask)[:, :, :max_len], nsff0, g=g)
-        return o
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminator, self).__init__()
-        periods = [2, 3, 5, 7, 11, 17]
-        # periods = [3, 5, 7, 11, 17, 23, 37]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [
-            DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
-        ]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []  #
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            # for j in range(len(fmap_r)):
-            #     print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class MultiPeriodDiscriminatorV2(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminatorV2, self).__init__()
-        # periods = [2, 3, 5, 7, 11, 17]
-        periods = [2, 3, 5, 7, 11, 17, 23, 37]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [
-            DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
-        ]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []  #
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            # for j in range(len(fmap_r)):
-            #     print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class DiscriminatorS(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(DiscriminatorS, self).__init__()
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(Conv1d(1, 16, 15, 1, padding=7)),
-                norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
-                norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
-                norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
-                norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
-                norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
-            ]
-        )
-        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x):
-        fmap = []
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.use_spectral_norm = use_spectral_norm
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(
-                    Conv2d(
-                        1,
-                        32,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        32,
-                        128,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        128,
-                        512,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        512,
-                        1024,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        1024,
-                        1024,
-                        (kernel_size, 1),
-                        1,
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-            ]
-        )
-        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0:  # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
diff --git a/spaces/Usaki108/VoiceChange/infer_pack/transforms.py b/spaces/Usaki108/VoiceChange/infer_pack/transforms.py
deleted file mode 100644
index a11f799e023864ff7082c1f49c0cc18351a13b47..0000000000000000000000000000000000000000
--- a/spaces/Usaki108/VoiceChange/infer_pack/transforms.py
+++ /dev/null
@@ -1,209 +0,0 @@
-import torch
-from torch.nn import functional as F
-
-import numpy as np
-
-
-DEFAULT_MIN_BIN_WIDTH = 1e-3
-DEFAULT_MIN_BIN_HEIGHT = 1e-3
-DEFAULT_MIN_DERIVATIVE = 1e-3
-
-
-def piecewise_rational_quadratic_transform(
-    inputs,
-    unnormalized_widths,
-    unnormalized_heights,
-    unnormalized_derivatives,
-    inverse=False,
-    tails=None,
-    tail_bound=1.0,
-    min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-    min_derivative=DEFAULT_MIN_DERIVATIVE,
-):
-    if tails is None:
-        spline_fn = rational_quadratic_spline
-        spline_kwargs = {}
-    else:
-        spline_fn = unconstrained_rational_quadratic_spline
-        spline_kwargs = {"tails": tails, "tail_bound": tail_bound}
-
-    outputs, logabsdet = spline_fn(
-        inputs=inputs,
-        unnormalized_widths=unnormalized_widths,
-        unnormalized_heights=unnormalized_heights,
-        unnormalized_derivatives=unnormalized_derivatives,
-        inverse=inverse,
-        min_bin_width=min_bin_width,
-        min_bin_height=min_bin_height,
-        min_derivative=min_derivative,
-        **spline_kwargs
-    )
-    return outputs, logabsdet
-
-
-def searchsorted(bin_locations, inputs, eps=1e-6):
-    bin_locations[..., -1] += eps
-    return torch.sum(inputs[..., None] >= bin_locations, dim=-1) - 1
-
-
-def unconstrained_rational_quadratic_spline(
-    inputs,
-    unnormalized_widths,
-    unnormalized_heights,
-    unnormalized_derivatives,
-    inverse=False,
-    tails="linear",
-    tail_bound=1.0,
-    min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-    min_derivative=DEFAULT_MIN_DERIVATIVE,
-):
-    inside_interval_mask = (inputs >= -tail_bound) & (inputs <= tail_bound)
-    outside_interval_mask = ~inside_interval_mask
-
-    outputs = torch.zeros_like(inputs)
-    logabsdet = torch.zeros_like(inputs)
-
-    if tails == "linear":
-        unnormalized_derivatives = F.pad(unnormalized_derivatives, pad=(1, 1))
-        constant = np.log(np.exp(1 - min_derivative) - 1)
-        unnormalized_derivatives[..., 0] = constant
-        unnormalized_derivatives[..., -1] = constant
-
-        outputs[outside_interval_mask] = inputs[outside_interval_mask]
-        logabsdet[outside_interval_mask] = 0
-    else:
-        raise RuntimeError("{} tails are not implemented.".format(tails))
-
-    (
-        outputs[inside_interval_mask],
-        logabsdet[inside_interval_mask],
-    ) = rational_quadratic_spline(
-        inputs=inputs[inside_interval_mask],
-        unnormalized_widths=unnormalized_widths[inside_interval_mask, :],
-        unnormalized_heights=unnormalized_heights[inside_interval_mask, :],
-        unnormalized_derivatives=unnormalized_derivatives[inside_interval_mask, :],
-        inverse=inverse,
-        left=-tail_bound,
-        right=tail_bound,
-        bottom=-tail_bound,
-        top=tail_bound,
-        min_bin_width=min_bin_width,
-        min_bin_height=min_bin_height,
-        min_derivative=min_derivative,
-    )
-
-    return outputs, logabsdet
-
-
-def rational_quadratic_spline(
-    inputs,
-    unnormalized_widths,
-    unnormalized_heights,
-    unnormalized_derivatives,
-    inverse=False,
-    left=0.0,
-    right=1.0,
-    bottom=0.0,
-    top=1.0,
-    min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-    min_derivative=DEFAULT_MIN_DERIVATIVE,
-):
-    if torch.min(inputs) < left or torch.max(inputs) > right:
-        raise ValueError("Input to a transform is not within its domain")
-
-    num_bins = unnormalized_widths.shape[-1]
-
-    if min_bin_width * num_bins > 1.0:
-        raise ValueError("Minimal bin width too large for the number of bins")
-    if min_bin_height * num_bins > 1.0:
-        raise ValueError("Minimal bin height too large for the number of bins")
-
-    widths = F.softmax(unnormalized_widths, dim=-1)
-    widths = min_bin_width + (1 - min_bin_width * num_bins) * widths
-    cumwidths = torch.cumsum(widths, dim=-1)
-    cumwidths = F.pad(cumwidths, pad=(1, 0), mode="constant", value=0.0)
-    cumwidths = (right - left) * cumwidths + left
-    cumwidths[..., 0] = left
-    cumwidths[..., -1] = right
-    widths = cumwidths[..., 1:] - cumwidths[..., :-1]
-
-    derivatives = min_derivative + F.softplus(unnormalized_derivatives)
-
-    heights = F.softmax(unnormalized_heights, dim=-1)
-    heights = min_bin_height + (1 - min_bin_height * num_bins) * heights
-    cumheights = torch.cumsum(heights, dim=-1)
-    cumheights = F.pad(cumheights, pad=(1, 0), mode="constant", value=0.0)
-    cumheights = (top - bottom) * cumheights + bottom
-    cumheights[..., 0] = bottom
-    cumheights[..., -1] = top
-    heights = cumheights[..., 1:] - cumheights[..., :-1]
-
-    if inverse:
-        bin_idx = searchsorted(cumheights, inputs)[..., None]
-    else:
-        bin_idx = searchsorted(cumwidths, inputs)[..., None]
-
-    input_cumwidths = cumwidths.gather(-1, bin_idx)[..., 0]
-    input_bin_widths = widths.gather(-1, bin_idx)[..., 0]
-
-    input_cumheights = cumheights.gather(-1, bin_idx)[..., 0]
-    delta = heights / widths
-    input_delta = delta.gather(-1, bin_idx)[..., 0]
-
-    input_derivatives = derivatives.gather(-1, bin_idx)[..., 0]
-    input_derivatives_plus_one = derivatives[..., 1:].gather(-1, bin_idx)[..., 0]
-
-    input_heights = heights.gather(-1, bin_idx)[..., 0]
-
-    if inverse:
-        a = (inputs - input_cumheights) * (
-            input_derivatives + input_derivatives_plus_one - 2 * input_delta
-        ) + input_heights * (input_delta - input_derivatives)
-        b = input_heights * input_derivatives - (inputs - input_cumheights) * (
-            input_derivatives + input_derivatives_plus_one - 2 * input_delta
-        )
-        c = -input_delta * (inputs - input_cumheights)
-
-        discriminant = b.pow(2) - 4 * a * c
-        assert (discriminant >= 0).all()
-
-        root = (2 * c) / (-b - torch.sqrt(discriminant))
-        outputs = root * input_bin_widths + input_cumwidths
-
-        theta_one_minus_theta = root * (1 - root)
-        denominator = input_delta + (
-            (input_derivatives + input_derivatives_plus_one - 2 * input_delta)
-            * theta_one_minus_theta
-        )
-        derivative_numerator = input_delta.pow(2) * (
-            input_derivatives_plus_one * root.pow(2)
-            + 2 * input_delta * theta_one_minus_theta
-            + input_derivatives * (1 - root).pow(2)
-        )
-        logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
-        return outputs, -logabsdet
-    else:
-        theta = (inputs - input_cumwidths) / input_bin_widths
-        theta_one_minus_theta = theta * (1 - theta)
-
-        numerator = input_heights * (
-            input_delta * theta.pow(2) + input_derivatives * theta_one_minus_theta
-        )
-        denominator = input_delta + (
-            (input_derivatives + input_derivatives_plus_one - 2 * input_delta)
-            * theta_one_minus_theta
-        )
-        outputs = input_cumheights + numerator / denominator
-
-        derivative_numerator = input_delta.pow(2) * (
-            input_derivatives_plus_one * theta.pow(2)
-            + 2 * input_delta * theta_one_minus_theta
-            + input_derivatives * (1 - theta).pow(2)
-        )
-        logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
-        return outputs, logabsdet
diff --git a/spaces/Vipitis/shadermatch/tests.py b/spaces/Vipitis/shadermatch/tests.py
deleted file mode 100644
index 2ff4a8563315944fe1d80c1a182d8f6e2d4761ca..0000000000000000000000000000000000000000
--- a/spaces/Vipitis/shadermatch/tests.py
+++ /dev/null
@@ -1,147 +0,0 @@
-## TODO: Add real examples
-
-default_shadertoy = """void mainImage( out vec4 fragColor, in vec2 fragCoord )
-{
-    // Normalized pixel coordinates (from 0 to 1)
-    vec2 uv = fragCoord/iResolution.xy;
-
-    // Time varying pixel color
-    vec3 col = 0.5 + 0.5*cos(iTime+uv.xyx+vec3(0,2,4));
-
-    // Output to screen
-    fragColor = vec4(col,1.0);
-}"""
-
-#different code, same output (removed comments, added .0)
-different_code = """void mainImage( out vec4 fragColor, in vec2 fragCoord )
-{
-    vec2 uv = fragCoord/iResolution.xy;
-
-    vec3 col = 0.5 + 0.5*cos(iTime+uv.xyx+vec3(0.0,2.0,4.0));
-
-    fragColor = vec4(col,1.0);
-}"""
-
-# different output (speed up time)
-different_output = """void mainImage( out vec4 fragColor, in vec2 fragCoord )
-{
-    vec2 uv = fragCoord/iResolution.xy;
-
-    vec3 col = 0.5 + 0.5*cos(iTime*3.33+uv.xyx+vec3(0,2,4));
-
-    fragColor = vec4(col,1.0);
-}"""
-
-# code error syntax (missing vec4 at the end)
-syntax_error = """void mainImage( out vec4 fragColor, in vec2 fragCoord )
-{
-    vec2 uv = fragCoord/iResolution.xy;
-
-    vec3 col = 0.5 + 0.5*cos(iTime+uv.xyx+vec3(0.0,2.0,4.0));
-
-    fragColor = (col,1.0);
-}"""
-
-# code error names (misspelled coll)
-name_error = """void mainImage( out vec4 fragColor, in vec2 fragCoord )
-{
-    vec2 uv = fragCoord/iResolution.xy;
-
-    vec3 col = 0.5 + 0.5*cos(iTime+uv.xyx+vec3(0.0,2.0,4.0));
-
-    fragColor = vec4(coll,1.0);
-}"""
-
-panic_shader = """
-// step 1: a funciton with an inout input and some other return value
-float fn(inout float a) {
-    a += 0.1;
-    return 0.2;
-}
-
-void mainImage( out vec4 fragColor, in vec2 fragCoord )
-{
-    // step 2: first variable that is vec2/vec3 (float works)
-    vec2 cd = vec2(0.3, 0.4);
-    
-    // step 3: second variable is assigned to the return value, using first variable as args.
-    float e = fn(cd.x);
-    
-    // Output to screen
-    fragColor = vec4(e);
-}
-"""
-
-panic_shader2 = """
-// 1. declare constant integers
-
-const int ID_left = 0;
-const int ID_right = 1;
-
-
-void mainImage( out vec4 fragColor, in vec2 fragCoord )
-{
-    vec2 uv = 2.0 * fragCoord/iResolution.xy;
-    
-    int side = int(uv.x);
- 
-    vec3 col = vec3(0.2);
-    
-    // 2. switch case on an int
-    switch(side)
-    {
-    // 3. use those constants 
-    case ID_left:
-    {
-        col *= 4.0;
-    }
-    case ID_right:
-    {
-        col *= 2.0;
-    }
-    }
-
-    fragColor = vec4(col,1.0);
-}
-
-"""
-
-test_cases = [
-    {
-        "predictions": [default_shadertoy],
-        "references": [default_shadertoy],
-        "result": {'text_match': 1.0, 'code_error': 0.0, 'image_match': 0.0} #also image match?
-    },
-    {
-        "predictions": [different_code],
-        "references": [default_shadertoy],
-        "result": {'text_match': 0.0, 'code_error': 0.0, 'image_match': 1.0} # same images as at any times is expected
-    },
-    {
-        "predictions": [different_output],
-        "references": [default_shadertoy],
-        "result": {'text_match': 0.0, 'code_error': 0.0, 'image_match': 0.1} # only time = 0 matches
-    },
-    {
-        "predictions": [syntax_error],
-        "references": [default_shadertoy],
-        "result": {'text_match': 0.0, 'code_error': 1.0, 'image_match': 0.0}
-    },
-    {
-        "predictions": [name_error],
-        "references": [default_shadertoy],
-        "result": {'text_match': 0.0, 'code_error': 1.0, 'image_match': 0.0} #unsure, does crash.
-    },
-    {
-        "predictions": [panic_shader],
-        "references": [default_shadertoy],
-        "result": {'text_match': 0.0, 'code_error': 0.0, 'image_match': 0.0} # this works on Shadertoy but panics in wgpu, we should filter this form out datasets instead.
-    },
-    {
-        "predictions": [panic_shader2],
-        "references": [default_shadertoy],
-        "result": {'text_match': 0.0, 'code_error': 0.0, 'image_match': 0.0} # same as above, but only get caught by wgsl translation
-    }
-
-
-]
\ No newline at end of file
diff --git a/spaces/Vynock/rvc-wefu/infer_pack/models.py b/spaces/Vynock/rvc-wefu/infer_pack/models.py
deleted file mode 100644
index 96165f73644e6fb92d0ffedb4a3c9e1a457cb989..0000000000000000000000000000000000000000
--- a/spaces/Vynock/rvc-wefu/infer_pack/models.py
+++ /dev/null
@@ -1,982 +0,0 @@
-import math, pdb, os
-from time import time as ttime
-import torch
-from torch import nn
-from torch.nn import functional as F
-from infer_pack import modules
-from infer_pack import attentions
-from infer_pack import commons
-from infer_pack.commons import init_weights, get_padding
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from infer_pack.commons import init_weights
-import numpy as np
-from infer_pack import commons
-
-
-class TextEncoder256(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(256, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        stats = self.proj(x) * x_mask
-
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        return m, logs, x_mask
-
-
-class TextEncoder256Sim(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(256, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        x = self.proj(x) * x_mask
-        return x, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        n_flows=4,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.flows = nn.ModuleList()
-        for i in range(n_flows):
-            self.flows.append(
-                modules.ResidualCouplingLayer(
-                    channels,
-                    hidden_channels,
-                    kernel_size,
-                    dilation_rate,
-                    n_layers,
-                    gin_channels=gin_channels,
-                    mean_only=True,
-                )
-            )
-            self.flows.append(modules.Flip())
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        if not reverse:
-            for flow in self.flows:
-                x, _ = flow(x, x_mask, g=g, reverse=reverse)
-        else:
-            for flow in reversed(self.flows):
-                x = flow(x, x_mask, g=g, reverse=reverse)
-        return x
-
-    def remove_weight_norm(self):
-        for i in range(self.n_flows):
-            self.flows[i * 2].remove_weight_norm()
-
-
-class PosteriorEncoder(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.gin_channels = gin_channels
-
-        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-        self.enc = modules.WN(
-            hidden_channels,
-            kernel_size,
-            dilation_rate,
-            n_layers,
-            gin_channels=gin_channels,
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, x, x_lengths, g=None):
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.pre(x) * x_mask
-        x = self.enc(x, x_mask, g=g)
-        stats = self.proj(x) * x_mask
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
-        return z, m, logs, x_mask
-
-    def remove_weight_norm(self):
-        self.enc.remove_weight_norm()
-
-
-class Generator(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels=0,
-    ):
-        super(Generator, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-    def forward(self, x, g=None):
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-class SineGen(torch.nn.Module):
-    """Definition of sine generator
-    SineGen(samp_rate, harmonic_num = 0,
-            sine_amp = 0.1, noise_std = 0.003,
-            voiced_threshold = 0,
-            flag_for_pulse=False)
-    samp_rate: sampling rate in Hz
-    harmonic_num: number of harmonic overtones (default 0)
-    sine_amp: amplitude of sine-wavefrom (default 0.1)
-    noise_std: std of Gaussian noise (default 0.003)
-    voiced_thoreshold: F0 threshold for U/V classification (default 0)
-    flag_for_pulse: this SinGen is used inside PulseGen (default False)
-    Note: when flag_for_pulse is True, the first time step of a voiced
-        segment is always sin(np.pi) or cos(0)
-    """
-
-    def __init__(
-        self,
-        samp_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        noise_std=0.003,
-        voiced_threshold=0,
-        flag_for_pulse=False,
-    ):
-        super(SineGen, self).__init__()
-        self.sine_amp = sine_amp
-        self.noise_std = noise_std
-        self.harmonic_num = harmonic_num
-        self.dim = self.harmonic_num + 1
-        self.sampling_rate = samp_rate
-        self.voiced_threshold = voiced_threshold
-
-    def _f02uv(self, f0):
-        # generate uv signal
-        uv = torch.ones_like(f0)
-        uv = uv * (f0 > self.voiced_threshold)
-        return uv
-
-    def forward(self, f0, upp):
-        """sine_tensor, uv = forward(f0)
-        input F0: tensor(batchsize=1, length, dim=1)
-                  f0 for unvoiced steps should be 0
-        output sine_tensor: tensor(batchsize=1, length, dim)
-        output uv: tensor(batchsize=1, length, 1)
-        """
-        with torch.no_grad():
-            f0 = f0[:, None].transpose(1, 2)
-            f0_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim, device=f0.device)
-            # fundamental component
-            f0_buf[:, :, 0] = f0[:, :, 0]
-            for idx in np.arange(self.harmonic_num):
-                f0_buf[:, :, idx + 1] = f0_buf[:, :, 0] * (
-                    idx + 2
-                )  # idx + 2: the (idx+1)-th overtone, (idx+2)-th harmonic
-            rad_values = (f0_buf / self.sampling_rate) % 1  ###%1意味着n_har的乘积无法后处理优化
-            rand_ini = torch.rand(
-                f0_buf.shape[0], f0_buf.shape[2], device=f0_buf.device
-            )
-            rand_ini[:, 0] = 0
-            rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
-            tmp_over_one = torch.cumsum(rad_values, 1)  # % 1  #####%1意味着后面的cumsum无法再优化
-            tmp_over_one *= upp
-            tmp_over_one = F.interpolate(
-                tmp_over_one.transpose(2, 1),
-                scale_factor=upp,
-                mode="linear",
-                align_corners=True,
-            ).transpose(2, 1)
-            rad_values = F.interpolate(
-                rad_values.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(
-                2, 1
-            )  #######
-            tmp_over_one %= 1
-            tmp_over_one_idx = (tmp_over_one[:, 1:, :] - tmp_over_one[:, :-1, :]) < 0
-            cumsum_shift = torch.zeros_like(rad_values)
-            cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
-            sine_waves = torch.sin(
-                torch.cumsum(rad_values + cumsum_shift, dim=1) * 2 * np.pi
-            )
-            sine_waves = sine_waves * self.sine_amp
-            uv = self._f02uv(f0)
-            uv = F.interpolate(
-                uv.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(2, 1)
-            noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
-            noise = noise_amp * torch.randn_like(sine_waves)
-            sine_waves = sine_waves * uv + noise
-        return sine_waves, uv, noise
-
-
-class SourceModuleHnNSF(torch.nn.Module):
-    """SourceModule for hn-nsf
-    SourceModule(sampling_rate, harmonic_num=0, sine_amp=0.1,
-                 add_noise_std=0.003, voiced_threshod=0)
-    sampling_rate: sampling_rate in Hz
-    harmonic_num: number of harmonic above F0 (default: 0)
-    sine_amp: amplitude of sine source signal (default: 0.1)
-    add_noise_std: std of additive Gaussian noise (default: 0.003)
-        note that amplitude of noise in unvoiced is decided
-        by sine_amp
-    voiced_threshold: threhold to set U/V given F0 (default: 0)
-    Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
-    F0_sampled (batchsize, length, 1)
-    Sine_source (batchsize, length, 1)
-    noise_source (batchsize, length 1)
-    uv (batchsize, length, 1)
-    """
-
-    def __init__(
-        self,
-        sampling_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        add_noise_std=0.003,
-        voiced_threshod=0,
-        is_half=True,
-    ):
-        super(SourceModuleHnNSF, self).__init__()
-
-        self.sine_amp = sine_amp
-        self.noise_std = add_noise_std
-        self.is_half = is_half
-        # to produce sine waveforms
-        self.l_sin_gen = SineGen(
-            sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshod
-        )
-
-        # to merge source harmonics into a single excitation
-        self.l_linear = torch.nn.Linear(harmonic_num + 1, 1)
-        self.l_tanh = torch.nn.Tanh()
-
-    def forward(self, x, upp=None):
-        sine_wavs, uv, _ = self.l_sin_gen(x, upp)
-        if self.is_half:
-            sine_wavs = sine_wavs.half()
-        sine_merge = self.l_tanh(self.l_linear(sine_wavs))
-        return sine_merge, None, None  # noise, uv
-
-
-class GeneratorNSF(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels,
-        sr,
-        is_half=False,
-    ):
-        super(GeneratorNSF, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-
-        self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(upsample_rates))
-        self.m_source = SourceModuleHnNSF(
-            sampling_rate=sr, harmonic_num=0, is_half=is_half
-        )
-        self.noise_convs = nn.ModuleList()
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            c_cur = upsample_initial_channel // (2 ** (i + 1))
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-            if i + 1 < len(upsample_rates):
-                stride_f0 = np.prod(upsample_rates[i + 1 :])
-                self.noise_convs.append(
-                    Conv1d(
-                        1,
-                        c_cur,
-                        kernel_size=stride_f0 * 2,
-                        stride=stride_f0,
-                        padding=stride_f0 // 2,
-                    )
-                )
-            else:
-                self.noise_convs.append(Conv1d(1, c_cur, kernel_size=1))
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-        self.upp = np.prod(upsample_rates)
-
-    def forward(self, x, f0, g=None):
-        har_source, noi_source, uv = self.m_source(f0, self.upp)
-        har_source = har_source.transpose(1, 2)
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            x_source = self.noise_convs[i](har_source)
-            x = x + x_source
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-sr2sr = {
-    "32k": 32000,
-    "40k": 40000,
-    "48k": 48000,
-}
-
-
-class SynthesizerTrnMs256NSFsid(nn.Module):
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        gin_channels,
-        sr,
-        **kwargs
-    ):
-        super().__init__()
-        if type(sr) == type("strr"):
-            sr = sr2sr[sr]
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder256(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-        )
-        self.dec = GeneratorNSF(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-            sr=sr,
-            is_half=kwargs["is_half"],
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(
-        self, phone, phone_lengths, pitch, pitchf, y, y_lengths, ds
-    ):  # 这里ds是id，[bs,1]
-        # print(1,pitch.shape)#[bs,t]
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
-        z_p = self.flow(z, y_mask, g=g)
-        z_slice, ids_slice = commons.rand_slice_segments(
-            z, y_lengths, self.segment_size
-        )
-        # print(-1,pitchf.shape,ids_slice,self.segment_size,self.hop_length,self.segment_size//self.hop_length)
-        pitchf = commons.slice_segments2(pitchf, ids_slice, self.segment_size)
-        # print(-2,pitchf.shape,z_slice.shape)
-        o = self.dec(z_slice, pitchf, g=g)
-        return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
-    def infer(self, phone, phone_lengths, pitch, nsff0, sid, max_len=None):
-        g = self.emb_g(sid).unsqueeze(-1)
-        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
-        z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec((z * x_mask)[:, :, :max_len], nsff0, g=g)
-        return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class SynthesizerTrnMs256NSFsid_nono(nn.Module):
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        gin_channels,
-        sr=None,
-        **kwargs
-    ):
-        super().__init__()
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder256(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-            f0=False,
-        )
-        self.dec = Generator(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(self, phone, phone_lengths, y, y_lengths, ds):  # 这里ds是id，[bs,1]
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
-        z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
-        z_p = self.flow(z, y_mask, g=g)
-        z_slice, ids_slice = commons.rand_slice_segments(
-            z, y_lengths, self.segment_size
-        )
-        o = self.dec(z_slice, g=g)
-        return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
-    def infer(self, phone, phone_lengths, sid, max_len=None):
-        g = self.emb_g(sid).unsqueeze(-1)
-        m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
-        z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
-        z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec((z * x_mask)[:, :, :max_len], g=g)
-        return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class SynthesizerTrnMs256NSFsid_sim(nn.Module):
-    """
-    Synthesizer for Training
-    """
-
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        # hop_length,
-        gin_channels=0,
-        use_sdp=True,
-        **kwargs
-    ):
-        super().__init__()
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder256Sim(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-        )
-        self.dec = GeneratorNSF(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-            is_half=kwargs["is_half"],
-        )
-
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(
-        self, phone, phone_lengths, pitch, pitchf, y_lengths, ds
-    ):  # y是spec不需要了现在
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        x, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        x = self.flow(x, x_mask, g=g, reverse=True)
-        z_slice, ids_slice = commons.rand_slice_segments(
-            x, y_lengths, self.segment_size
-        )
-
-        pitchf = commons.slice_segments2(pitchf, ids_slice, self.segment_size)
-        o = self.dec(z_slice, pitchf, g=g)
-        return o, ids_slice
-
-    def infer(
-        self, phone, phone_lengths, pitch, pitchf, ds, max_len=None
-    ):  # y是spec不需要了现在
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        x, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        x = self.flow(x, x_mask, g=g, reverse=True)
-        o = self.dec((x * x_mask)[:, :, :max_len], pitchf, g=g)
-        return o, o
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminator, self).__init__()
-        periods = [2, 3, 5, 7, 11, 17]
-        # periods = [3, 5, 7, 11, 17, 23, 37]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [
-            DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
-        ]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []  #
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            # for j in range(len(fmap_r)):
-            #     print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class DiscriminatorS(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(DiscriminatorS, self).__init__()
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(Conv1d(1, 16, 15, 1, padding=7)),
-                norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
-                norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
-                norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
-                norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
-                norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
-            ]
-        )
-        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x):
-        fmap = []
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.use_spectral_norm = use_spectral_norm
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(
-                    Conv2d(
-                        1,
-                        32,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        32,
-                        128,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        128,
-                        512,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        512,
-                        1024,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        1024,
-                        1024,
-                        (kernel_size, 1),
-                        1,
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-            ]
-        )
-        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0:  # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
diff --git a/spaces/Xixeo/Face_Recognition/util/fonts_opt.py b/spaces/Xixeo/Face_Recognition/util/fonts_opt.py
deleted file mode 100644
index 799441cac5a16b3a2ec703856006a26a5190e9de..0000000000000000000000000000000000000000
--- a/spaces/Xixeo/Face_Recognition/util/fonts_opt.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# 字体管理
-# 创建人：曾逸夫
-# 创建时间：2022-05-01
-
-import os
-import sys
-from pathlib import Path
-
-import wget
-from rich.console import Console
-
-ROOT_PATH = sys.path[0]  # 项目根目录
-
-# 中文、英文、俄语、西班牙语、阿拉伯语、韩语
-fonts_list = ["SimSun.ttf", "TimesNewRoman.ttf", "malgun.ttf"]  # 字体列表
-fonts_suffix = ["ttc", "ttf", "otf"]  # 字体后缀
-
-data_url_dict = {
-    "SimSun.ttf": "https://gitee.com/CV_Lab/gradio_yolov5_det/attach_files/1053539/download/SimSun.ttf",
-    "TimesNewRoman.ttf": "https://gitee.com/CV_Lab/gradio_yolov5_det/attach_files/1053537/download/TimesNewRoman.ttf",
-    "malgun.ttf": "https://gitee.com/CV_Lab/gradio_yolov5_det/attach_files/1053538/download/malgun.ttf",}
-
-console = Console()
-
-
-# 创建字体库
-def add_fronts(font_diff):
-
-    global font_name
-
-    for k, v in data_url_dict.items():
-        if k in font_diff:
-            font_name = v.split("/")[-1]  # 字体名称
-            Path(f"{ROOT_PATH}/fonts").mkdir(parents=True, exist_ok=True)  # 创建目录
-
-            file_path = f"{ROOT_PATH}/fonts/{font_name}"  # 字体路径
-
-            try:
-                # 下载字体文件
-                wget.download(v, file_path)
-            except Exception as e:
-                print("路径错误！程序结束！")
-                print(e)
-                sys.exit()
-            else:
-                print()
-                console.print(f"{font_name} [bold green]字体文件下载完成！[/bold green] 已保存至：{file_path}")
-
-
-# 判断字体文件
-def is_fonts(fonts_dir):
-    if os.path.isdir(fonts_dir):
-        # 如果字体库存在
-        f_list = os.listdir(fonts_dir)  # 本地字体库
-
-        font_diff = list(set(fonts_list).difference(set(f_list)))
-
-        if font_diff != []:
-            # 字体不存在
-            console.print("[bold red]字体不存在，正在加载。。。[/bold red]")
-            add_fronts(font_diff)  # 创建字体库
-        else:
-            console.print(f"{fonts_list}[bold green]字体已存在！[/bold green]")
-    else:
-        # 字体库不存在，创建字体库
-        console.print("[bold red]字体库不存在，正在创建。。。[/bold red]")
-        add_fronts(fonts_list)  # 创建字体库
diff --git a/spaces/XzJosh/LittleTaffy-Bert-VITS2/text/chinese.py b/spaces/XzJosh/LittleTaffy-Bert-VITS2/text/chinese.py
deleted file mode 100644
index 276753880b73de2e8889dcb2101cd98c09e0710b..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/LittleTaffy-Bert-VITS2/text/chinese.py
+++ /dev/null
@@ -1,193 +0,0 @@
-import os
-import re
-
-import cn2an
-from pypinyin import lazy_pinyin, Style
-
-from text import symbols
-from text.symbols import punctuation
-from text.tone_sandhi import ToneSandhi
-
-current_file_path = os.path.dirname(__file__)
-pinyin_to_symbol_map = {line.split("\t")[0]: line.strip().split("\t")[1] for line in
-                        open(os.path.join(current_file_path, 'opencpop-strict.txt')).readlines()}
-
-import jieba.posseg as psg
-
-
-rep_map = {
-    '：': ',',
-    '；': ',',
-    '，': ',',
-    '。': '.',
-    '！': '!',
-    '？': '?',
-    '\n': '.',
-    "·": ",",
-    '、': ",",
-    '...': '…',
-    '$': '.',
-    '“': "'",
-    '”': "'",
-    '‘': "'",
-    '’': "'",
-    '（': "'",
-    '）': "'",
-    '(': "'",
-    ')': "'",
-    '《': "'",
-    '》': "'",
-    '【': "'",
-    '】': "'",
-    '[': "'",
-    ']': "'",
-    '—': "-",
-    '～': "-",
-    '~': "-",
-    '「': "'",
-    '」': "'",
-
-}
-
-tone_modifier = ToneSandhi()
-
-def replace_punctuation(text):
-    text = text.replace("嗯", "恩").replace("呣","母")
-    pattern = re.compile('|'.join(re.escape(p) for p in rep_map.keys()))
-
-    replaced_text = pattern.sub(lambda x: rep_map[x.group()], text)
-
-    replaced_text = re.sub(r'[^\u4e00-\u9fa5'+"".join(punctuation)+r']+', '', replaced_text)
-
-    return replaced_text
-
-def g2p(text):
-    pattern = r'(?<=[{0}])\s*'.format(''.join(punctuation))
-    sentences = [i for i in re.split(pattern, text) if i.strip()!='']
-    phones, tones, word2ph = _g2p(sentences)
-    assert sum(word2ph) == len(phones)
-    assert len(word2ph) == len(text) #Sometimes it will crash,you can add a try-catch.
-    phones = ['_'] + phones + ["_"]
-    tones = [0] + tones + [0]
-    word2ph = [1] + word2ph + [1]
-    return phones, tones, word2ph
-
-
-def _get_initials_finals(word):
-    initials = []
-    finals = []
-    orig_initials = lazy_pinyin(
-        word, neutral_tone_with_five=True, style=Style.INITIALS)
-    orig_finals = lazy_pinyin(
-        word, neutral_tone_with_five=True, style=Style.FINALS_TONE3)
-    for c, v in zip(orig_initials, orig_finals):
-        initials.append(c)
-        finals.append(v)
-    return initials, finals
-
-
-def _g2p(segments):
-    phones_list = []
-    tones_list = []
-    word2ph = []
-    for seg in segments:
-        pinyins = []
-        # Replace all English words in the sentence
-        seg = re.sub('[a-zA-Z]+', '', seg)
-        seg_cut = psg.lcut(seg)
-        initials = []
-        finals = []
-        seg_cut = tone_modifier.pre_merge_for_modify(seg_cut)
-        for word, pos in seg_cut:
-            if pos == 'eng':
-                continue
-            sub_initials, sub_finals = _get_initials_finals(word)
-            sub_finals = tone_modifier.modified_tone(word, pos,
-                                                          sub_finals)
-            initials.append(sub_initials)
-            finals.append(sub_finals)
-
-            # assert len(sub_initials) == len(sub_finals) == len(word)
-        initials = sum(initials, [])
-        finals = sum(finals, [])
-        #
-        for c, v in zip(initials, finals):
-            raw_pinyin = c+v
-            # NOTE: post process for pypinyin outputs
-            # we discriminate i, ii and iii
-            if c == v:
-                assert c in punctuation
-                phone = [c]
-                tone = '0'
-                word2ph.append(1)
-            else:
-                v_without_tone = v[:-1]
-                tone = v[-1]
-
-                pinyin = c+v_without_tone
-                assert tone in '12345'
-
-                if c:
-                    # 多音节
-                    v_rep_map = {
-                        "uei": 'ui',
-                        'iou': 'iu',
-                        'uen': 'un',
-                    }
-                    if v_without_tone in v_rep_map.keys():
-                        pinyin = c+v_rep_map[v_without_tone]
-                else:
-                    # 单音节
-                    pinyin_rep_map = {
-                        'ing': 'ying',
-                        'i': 'yi',
-                        'in': 'yin',
-                        'u': 'wu',
-                    }
-                    if pinyin in pinyin_rep_map.keys():
-                        pinyin = pinyin_rep_map[pinyin]
-                    else:
-                        single_rep_map = {
-                            'v': 'yu',
-                            'e': 'e',
-                            'i': 'y',
-                            'u': 'w',
-                        }
-                        if pinyin[0] in single_rep_map.keys():
-                            pinyin = single_rep_map[pinyin[0]]+pinyin[1:]
-
-                assert pinyin in pinyin_to_symbol_map.keys(), (pinyin, seg, raw_pinyin)
-                phone = pinyin_to_symbol_map[pinyin].split(' ')
-                word2ph.append(len(phone))
-
-            phones_list += phone
-            tones_list += [int(tone)] * len(phone)
-    return phones_list, tones_list, word2ph
-
-
-
-def text_normalize(text):
-    numbers = re.findall(r'\d+(?:\.?\d+)?', text)
-    for number in numbers:
-        text = text.replace(number, cn2an.an2cn(number), 1)
-    text = replace_punctuation(text)
-    return text
-
-def get_bert_feature(text, word2ph):
-    from  text import chinese_bert
-    return chinese_bert.get_bert_feature(text, word2ph)
-
-if __name__ == '__main__':
-    from text.chinese_bert import get_bert_feature
-    text = "啊！但是《原神》是由,米哈\游自主，  [研发]的一款全.新开放世界.冒险游戏"
-    text = text_normalize(text)
-    print(text)
-    phones, tones, word2ph = g2p(text)
-    bert = get_bert_feature(text, word2ph)
-
-    print(phones, tones, word2ph, bert.shape)
-
-
-# # 示例用法
-# text = "这是一个示例文本：,你好！这是一个测试...."
-# print(g2p_paddle(text))  # 输出: 这是一个示例文本你好这是一个测试
diff --git a/spaces/XzJosh/XingTong-Bert-VITS2/text/english_bert_mock.py b/spaces/XzJosh/XingTong-Bert-VITS2/text/english_bert_mock.py
deleted file mode 100644
index 3b894ced5b6d619a18d6bdd7d7606ba9e6532050..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/XingTong-Bert-VITS2/text/english_bert_mock.py
+++ /dev/null
@@ -1,5 +0,0 @@
-import torch
-
-
-def get_bert_feature(norm_text, word2ph):
-    return torch.zeros(1024, sum(word2ph))
diff --git a/spaces/XzJosh/otto-Bert-VITS2/app.py b/spaces/XzJosh/otto-Bert-VITS2/app.py
deleted file mode 100644
index f273afa29297fdec392a50cc2bd6b99e9613aa86..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/otto-Bert-VITS2/app.py
+++ /dev/null
@@ -1,149 +0,0 @@
-import sys, os
-
-if sys.platform == "darwin":
-    os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
-
-import logging
-
-logging.getLogger("numba").setLevel(logging.WARNING)
-logging.getLogger("markdown_it").setLevel(logging.WARNING)
-logging.getLogger("urllib3").setLevel(logging.WARNING)
-logging.getLogger("matplotlib").setLevel(logging.WARNING)
-
-logging.basicConfig(level=logging.INFO, format="| %(name)s | %(levelname)s | %(message)s")
-
-logger = logging.getLogger(__name__)
-
-import torch
-import argparse
-import commons
-import utils
-from models import SynthesizerTrn
-from text.symbols import symbols
-from text import cleaned_text_to_sequence, get_bert
-from text.cleaner import clean_text
-import gradio as gr
-import webbrowser
-
-
-net_g = None
-
-
-def get_text(text, language_str, hps):
-    norm_text, phone, tone, word2ph = clean_text(text, language_str)
-    phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
-
-    if hps.data.add_blank:
-        phone = commons.intersperse(phone, 0)
-        tone = commons.intersperse(tone, 0)
-        language = commons.intersperse(language, 0)
-        for i in range(len(word2ph)):
-            word2ph[i] = word2ph[i] * 2
-        word2ph[0] += 1
-    bert = get_bert(norm_text, word2ph, language_str)
-    del word2ph
-
-    assert bert.shape[-1] == len(phone)
-
-    phone = torch.LongTensor(phone)
-    tone = torch.LongTensor(tone)
-    language = torch.LongTensor(language)
-
-    return bert, phone, tone, language
-
-def infer(text, sdp_ratio, noise_scale, noise_scale_w, length_scale, sid):
-    global net_g
-    bert, phones, tones, lang_ids = get_text(text, "ZH", hps)
-    with torch.no_grad():
-        x_tst=phones.to(device).unsqueeze(0)
-        tones=tones.to(device).unsqueeze(0)
-        lang_ids=lang_ids.to(device).unsqueeze(0)
-        bert = bert.to(device).unsqueeze(0)
-        x_tst_lengths = torch.LongTensor([phones.size(0)]).to(device)
-        del phones
-        speakers = torch.LongTensor([hps.data.spk2id[sid]]).to(device)
-        audio = net_g.infer(x_tst, x_tst_lengths, speakers, tones, lang_ids, bert, sdp_ratio=sdp_ratio
-                           , noise_scale=noise_scale, noise_scale_w=noise_scale_w, length_scale=length_scale)[0][0,0].data.cpu().float().numpy()
-        del x_tst, tones, lang_ids, bert, x_tst_lengths, speakers
-        return audio
-
-def tts_fn(text, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale):
-    with torch.no_grad():
-        audio = infer(text, sdp_ratio=sdp_ratio, noise_scale=noise_scale, noise_scale_w=noise_scale_w, length_scale=length_scale, sid=speaker)
-    return "Success", (hps.data.sampling_rate, audio)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model_dir", default="./logs/otto/G_5900.pth", help="path of your model")
-    parser.add_argument("--config_dir", default="./configs/config.json", help="path of your config file")
-    parser.add_argument("--share", default=False, help="make link public")
-    parser.add_argument("-d", "--debug", action="store_true", help="enable DEBUG-LEVEL log")
-
-    args = parser.parse_args()
-    if args.debug:
-        logger.info("Enable DEBUG-LEVEL log")
-        logging.basicConfig(level=logging.DEBUG)
-    hps = utils.get_hparams_from_file(args.config_dir)
-    device = "cuda:0" if torch.cuda.is_available() else "cpu"
-    '''
-    device = (
-        "cuda:0"
-        if torch.cuda.is_available()
-        else (
-            "mps"
-            if sys.platform == "darwin" and torch.backends.mps.is_available()
-            else "cpu"
-        )
-    )
-    '''
-    net_g = SynthesizerTrn(
-        len(symbols),
-        hps.data.filter_length // 2 + 1,
-        hps.train.segment_size // hps.data.hop_length,
-        n_speakers=hps.data.n_speakers,
-        **hps.model).to(device)
-    _ = net_g.eval()
-
-    _ = utils.load_checkpoint(args.model_dir, net_g, None, skip_optimizer=True)
-
-    speaker_ids = hps.data.spk2id
-    speakers = list(speaker_ids.keys())
-    with gr.Blocks() as app:
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown(value="""
-                【AI电棍】在线语音合成（Bert-Vits2）\n
-                作者：Xz乔希 https://space.bilibili.com/5859321\n
-                声音归属：电棍otto https://space.bilibili.com/628845081\n
-                Bert-VITS2项目：https://github.com/Stardust-minus/Bert-VITS2\n
-                【AI电棍②】https://huggingface.co/spaces/XzJosh/Gun-Bert-VITS2\n
-                使用本模型请严格遵守法律法规！\n
-                发布二创作品请标注本项目作者及链接、作品使用Bert-VITS2 AI生成！\n                
-                """)
-                text = gr.TextArea(label="Text", placeholder="Input Text Here",
-                                      value="大家好啊，我是电棍。今天来点大家想看的东西啊。")
-                speaker = gr.Dropdown(choices=speakers, value=speakers[0], label='Speaker')
-                sdp_ratio = gr.Slider(minimum=0.1, maximum=1, value=0.2, step=0.01, label='SDP/DP混合比')
-                noise_scale = gr.Slider(minimum=0.1, maximum=1, value=0.5, step=0.01, label='感情调节')
-                noise_scale_w = gr.Slider(minimum=0.1, maximum=1, value=0.9, step=0.01, label='音素长度')
-                length_scale = gr.Slider(minimum=0.1, maximum=2, value=1, step=0.01, label='生成长度')
-                btn = gr.Button("点击生成", variant="primary")
-            with gr.Column():
-                text_output = gr.Textbox(label="Message")
-                audio_output = gr.Audio(label="Output Audio")
-                gr.Markdown(value="""
-                【AI塔菲】https://huggingface.co/spaces/XzJosh/Taffy-Bert-VITS2\n
-                【AI东雪莲】https://huggingface.co/spaces/XzJosh/Azuma-Bert-VITS2\n
-                【AI奶绿】https://huggingface.co/spaces/XzJosh/LAPLACE-Bert-VITS2\n
-                【AI尼奈】https://huggingface.co/spaces/XzJosh/nine1-Bert-VITS2\n
-                【AI珈乐】https://huggingface.co/spaces/XzJosh/Carol-Bert-VITS2\n
-                 """)
-        btn.click(tts_fn,
-                inputs=[text, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale],
-                outputs=[text_output, audio_output])
-    
-#    webbrowser.open("http://127.0.0.1:6006")
-#    app.launch(server_port=6006, show_error=True)
-        
-    app.launch(show_error=True)
diff --git a/spaces/Y-T-G/Blur-Anything/utils/interact_tools.py b/spaces/Y-T-G/Blur-Anything/utils/interact_tools.py
deleted file mode 100644
index 02a3a33941ec9957e09f5a238a24fe4acccce97f..0000000000000000000000000000000000000000
--- a/spaces/Y-T-G/Blur-Anything/utils/interact_tools.py
+++ /dev/null
@@ -1,109 +0,0 @@
-from PIL import Image
-import numpy as np
-from .base_segmenter import BaseSegmenter
-from .painter import mask_painter, point_painter
-
-
-mask_color = 3
-mask_alpha = 0.7
-contour_color = 1
-contour_width = 5
-point_color_ne = 8
-point_color_ps = 50
-point_alpha = 0.9
-point_radius = 15
-contour_color = 2
-contour_width = 5
-
-
-class SamControler:
-    def __init__(self, sam_pt_checkpoint, sam_onnx_checkpoint, model_type, device):
-        """
-        initialize sam controler
-        """
-
-        self.sam_controler = BaseSegmenter(sam_pt_checkpoint, sam_onnx_checkpoint, model_type, device)
-        self.onnx = model_type == "vit_t"
-
-    def first_frame_click(
-        self,
-        image: np.ndarray,
-        points: np.ndarray,
-        labels: np.ndarray,
-        multimask=True,
-        mask_color=3,
-    ):
-        """
-        it is used in first frame in video
-        return: mask, logit, painted image(mask+point)
-        """
-        # self.sam_controler.set_image(image)
-        neg_flag = labels[-1]
-
-        if self.onnx:
-            onnx_coord = np.concatenate([points, np.array([[0.0, 0.0]])], axis=0)[None, :, :]
-            onnx_label = np.concatenate([labels, np.array([-1])], axis=0)[None, :].astype(np.float32)
-            onnx_coord = self.sam_controler.predictor.transform.apply_coords(onnx_coord, image.shape[:2]).astype(np.float32)
-            prompts = {
-                "point_coords": onnx_coord,
-                "point_labels": onnx_label,
-                "orig_im_size": np.array(image.shape[:2], dtype=np.float32),
-            }
-
-        else:
-            prompts = {
-                "point_coords": points,
-                "point_labels": labels,
-            }
-
-        if neg_flag == 1:
-            # find positive
-            masks, scores, logits = self.sam_controler.predict(
-                prompts, "point", multimask
-            )
-            mask, logit = masks[np.argmax(scores)], logits[np.argmax(scores), :, :]
-
-            prompts["mask_input"] = np.expand_dims(logit[None, :, :], 0)
-            masks, scores, logits = self.sam_controler.predict(
-                prompts, "both", multimask
-            )
-            mask, logit = masks[np.argmax(scores)], logits[np.argmax(scores), :, :]
-
-        else:
-            # find neg
-            masks, scores, logits = self.sam_controler.predict(
-                prompts, "point", multimask
-            )
-            mask, logit = masks[np.argmax(scores)], logits[np.argmax(scores), :, :]
-
-        assert len(points) == len(labels)
-
-        painted_image = mask_painter(
-            image,
-            mask.astype("uint8"),
-            mask_color,
-            mask_alpha,
-            contour_color,
-            contour_width,
-        )
-        painted_image = point_painter(
-            painted_image,
-            np.squeeze(points[np.argwhere(labels > 0)], axis=1),
-            point_color_ne,
-            point_alpha,
-            point_radius,
-            contour_color,
-            contour_width,
-        )
-        painted_image = point_painter(
-            painted_image,
-            np.squeeze(points[np.argwhere(labels < 1)], axis=1),
-            point_color_ps,
-            point_alpha,
-            point_radius,
-            contour_color,
-            contour_width,
-        )
-        painted_image = Image.fromarray(painted_image)
-
-        return mask, logit, painted_image
diff --git a/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/layers/csrc/nms_rotated/nms_rotated_cpu.cpp b/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/layers/csrc/nms_rotated/nms_rotated_cpu.cpp
deleted file mode 100644
index d7556e645b604aa83d86cc702b783fd8ecedffcc..0000000000000000000000000000000000000000
--- a/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/layers/csrc/nms_rotated/nms_rotated_cpu.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates.
-#include "../box_iou_rotated/box_iou_rotated_utils.h"
-#include "nms_rotated.h"
-
-namespace detectron2 {
-
-template <typename scalar_t>
-at::Tensor nms_rotated_cpu_kernel(
-    const at::Tensor& dets,
-    const at::Tensor& scores,
-    const double iou_threshold) {
-  // nms_rotated_cpu_kernel is modified from torchvision's nms_cpu_kernel,
-  // however, the code in this function is much shorter because
-  // we delegate the IoU computation for rotated boxes to
-  // the single_box_iou_rotated function in box_iou_rotated_utils.h
-  AT_ASSERTM(dets.device().is_cpu(), "dets must be a CPU tensor");
-  AT_ASSERTM(scores.device().is_cpu(), "scores must be a CPU tensor");
-  AT_ASSERTM(
-      dets.scalar_type() == scores.scalar_type(),
-      "dets should have the same type as scores");
-
-  if (dets.numel() == 0) {
-    return at::empty({0}, dets.options().dtype(at::kLong));
-  }
-
-  auto order_t = std::get<1>(scores.sort(0, /* descending=*/true));
-
-  auto ndets = dets.size(0);
-  at::Tensor suppressed_t = at::zeros({ndets}, dets.options().dtype(at::kByte));
-  at::Tensor keep_t = at::zeros({ndets}, dets.options().dtype(at::kLong));
-
-  auto suppressed = suppressed_t.data_ptr<uint8_t>();
-  auto keep = keep_t.data_ptr<int64_t>();
-  auto order = order_t.data_ptr<int64_t>();
-
-  int64_t num_to_keep = 0;
-
-  for (int64_t _i = 0; _i < ndets; _i++) {
-    auto i = order[_i];
-    if (suppressed[i] == 1) {
-      continue;
-    }
-
-    keep[num_to_keep++] = i;
-
-    for (int64_t _j = _i + 1; _j < ndets; _j++) {
-      auto j = order[_j];
-      if (suppressed[j] == 1) {
-        continue;
-      }
-
-      auto ovr = single_box_iou_rotated<scalar_t>(
-          dets[i].data_ptr<scalar_t>(), dets[j].data_ptr<scalar_t>());
-      if (ovr >= iou_threshold) {
-        suppressed[j] = 1;
-      }
-    }
-  }
-  return keep_t.narrow(/*dim=*/0, /*start=*/0, /*length=*/num_to_keep);
-}
-
-at::Tensor nms_rotated_cpu(
-    // input must be contiguous
-    const at::Tensor& dets,
-    const at::Tensor& scores,
-    const double iou_threshold) {
-  auto result = at::empty({0}, dets.options());
-
-  AT_DISPATCH_FLOATING_TYPES(dets.scalar_type(), "nms_rotated", [&] {
-    result = nms_rotated_cpu_kernel<scalar_t>(dets, scores, iou_threshold);
-  });
-  return result;
-}
-
-} // namespace detectron2
diff --git a/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/layers/roi_align.py b/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/layers/roi_align.py
deleted file mode 100644
index 163462e1f194e1e4100da92d76d9516f7cc22e35..0000000000000000000000000000000000000000
--- a/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/layers/roi_align.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from torch import nn
-from torchvision.ops import roi_align
-
-
-# NOTE: torchvision's RoIAlign has a different default aligned=False
-class ROIAlign(nn.Module):
-    def __init__(self, output_size, spatial_scale, sampling_ratio, aligned=True):
-        """
-        Args:
-            output_size (tuple): h, w
-            spatial_scale (float): scale the input boxes by this number
-            sampling_ratio (int): number of inputs samples to take for each output
-                sample. 0 to take samples densely.
-            aligned (bool): if False, use the legacy implementation in
-                Detectron. If True, align the results more perfectly.
-
-        Note:
-            The meaning of aligned=True:
-
-            Given a continuous coordinate c, its two neighboring pixel indices (in our
-            pixel model) are computed by floor(c - 0.5) and ceil(c - 0.5). For example,
-            c=1.3 has pixel neighbors with discrete indices [0] and [1] (which are sampled
-            from the underlying signal at continuous coordinates 0.5 and 1.5). But the original
-            roi_align (aligned=False) does not subtract the 0.5 when computing neighboring
-            pixel indices and therefore it uses pixels with a slightly incorrect alignment
-            (relative to our pixel model) when performing bilinear interpolation.
-
-            With `aligned=True`,
-            we first appropriately scale the ROI and then shift it by -0.5
-            prior to calling roi_align. This produces the correct neighbors; see
-            detectron2/tests/test_roi_align.py for verification.
-
-            The difference does not make a difference to the model's performance if
-            ROIAlign is used together with conv layers.
-        """
-        super().__init__()
-        self.output_size = output_size
-        self.spatial_scale = spatial_scale
-        self.sampling_ratio = sampling_ratio
-        self.aligned = aligned
-
-        from torchvision import __version__
-
-        version = tuple(int(x) for x in __version__.split(".")[:2])
-        # https://github.com/pytorch/vision/pull/2438
-        assert version >= (0, 7), "Require torchvision >= 0.7"
-
-    def forward(self, input, rois):
-        """
-        Args:
-            input: NCHW images
-            rois: Bx5 boxes. First column is the index into N. The other 4 columns are xyxy.
-        """
-        assert rois.dim() == 2 and rois.size(1) == 5
-        if input.is_quantized:
-            input = input.dequantize()
-        return roi_align(
-            input,
-            rois.to(dtype=input.dtype),
-            self.output_size,
-            self.spatial_scale,
-            self.sampling_ratio,
-            self.aligned,
-        )
-
-    def __repr__(self):
-        tmpstr = self.__class__.__name__ + "("
-        tmpstr += "output_size=" + str(self.output_size)
-        tmpstr += ", spatial_scale=" + str(self.spatial_scale)
-        tmpstr += ", sampling_ratio=" + str(self.sampling_ratio)
-        tmpstr += ", aligned=" + str(self.aligned)
-        tmpstr += ")"
-        return tmpstr
diff --git a/spaces/YouLiXiya/Mobile-SAM/segment_anything/segment_anything/__init__.py b/spaces/YouLiXiya/Mobile-SAM/segment_anything/segment_anything/__init__.py
deleted file mode 100644
index fc126f98c0fbe5a505c5b9e1c937e15f21f06137..0000000000000000000000000000000000000000
--- a/spaces/YouLiXiya/Mobile-SAM/segment_anything/segment_anything/__init__.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from .build_sam import (
-    build_sam,
-    build_sam_vit_h,
-    build_sam_vit_l,
-    build_sam_vit_b,
-    sam_model_registry,
-)
-from .build_sam_hq import (
-    build_sam_hq,
-    build_sam_hq_vit_h,
-    build_sam_hq_vit_l,
-    build_sam_hq_vit_b,
-    sam_hq_model_registry,
-)
-from .predictor import SamPredictor, SamEncoder, SamDecoder, sam_decode, segment
-from .automatic_mask_generator import SamAutomaticMaskGenerator
-from .mobile_encoder.setup_mobile_sam import setup_model, load_mobile_sam
diff --git a/spaces/Zaixi/ICLR_FLAG/models/encoders/schnet.py b/spaces/Zaixi/ICLR_FLAG/models/encoders/schnet.py
deleted file mode 100644
index c7aa700dd23c6b3e8d1da0a1e0d57dcfb877f598..0000000000000000000000000000000000000000
--- a/spaces/Zaixi/ICLR_FLAG/models/encoders/schnet.py
+++ /dev/null
@@ -1,105 +0,0 @@
-import torch
-import torch.nn.functional as F
-from torch.nn import Module, Sequential, ModuleList, Linear
-from torch_geometric.nn import MessagePassing, radius_graph
-from math import pi as PI
-
-from ..common import GaussianSmearing, ShiftedSoftplus
-
-
-class CFConv(MessagePassing):
-
-    def __init__(self, in_channels, out_channels, num_filters, edge_channels, cutoff=10.0):
-        super().__init__(aggr='add')
-        self.lin1 = Linear(in_channels, num_filters, bias=False)
-        self.lin2 = Linear(num_filters, out_channels)
-        self.nn = Sequential(
-            Linear(edge_channels, num_filters),
-            ShiftedSoftplus(),
-            Linear(num_filters, num_filters),
-        )   # Network for generating filter weights
-        self.cutoff = cutoff
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        torch.nn.init.xavier_uniform_(self.nn[0].weight)
-        self.nn[0].bias.data.fill_(0)
-        torch.nn.init.xavier_uniform_(self.nn[2].weight)
-        self.nn[0].bias.data.fill_(0)
-        torch.nn.init.xavier_uniform_(self.lin1.weight)
-        torch.nn.init.xavier_uniform_(self.lin2.weight)
-        self.lin2.bias.data.fill_(0)
-
-    def forward(self, x, edge_index, edge_length, edge_attr):
-        W = self.nn(edge_attr)
-
-        if self.cutoff is not None:
-            C = 0.5 * (torch.cos(edge_length * PI / self.cutoff) + 1.0)
-            C = C * (edge_length <= self.cutoff) * (edge_length >= 0.0)     # Modification: cutoff
-            W = W * C.view(-1, 1)
-
-        x = self.lin1(x)
-        x = self.propagate(edge_index, x=x, W=W)
-        x = self.lin2(x)
-        return x
-
-    def message(self, x_j, W):
-        return x_j * W
-
-
-class InteractionBlock(Module):
-
-    def __init__(self, hidden_channels, num_gaussians, num_filters, cutoff):
-        super(InteractionBlock, self).__init__()
-        self.conv = CFConv(hidden_channels, hidden_channels, num_filters, num_gaussians, cutoff)
-        self.act = ShiftedSoftplus()
-        self.lin = Linear(hidden_channels, hidden_channels)
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        self.conv.reset_parameters()
-        torch.nn.init.xavier_uniform_(self.lin.weight)
-        self.lin.bias.data.fill_(0)
-
-    def forward(self, x, edge_index, edge_length, edge_attr):
-        x = self.conv(x, edge_index, edge_length, edge_attr)
-        x = self.act(x)
-        x = self.lin(x)
-        return x
-
-
-class SchNetEncoder(Module):
-
-    def __init__(self, hidden_channels=128, num_filters=128,
-                num_interactions=6, edge_channels=64, cutoff=10.0):
-        super().__init__()
-
-        self.hidden_channels = hidden_channels
-        self.num_filters = num_filters
-        self.num_interactions = num_interactions
-        self.distance_expansion = GaussianSmearing(stop=cutoff, num_gaussians=edge_channels)
-        self.cutoff = cutoff
-
-        self.interactions = ModuleList()
-        for _ in range(num_interactions):
-            block = InteractionBlock(hidden_channels, edge_channels,
-                                     num_filters, cutoff)
-            self.interactions.append(block)
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        for interaction in self.interactions:
-            interaction.reset_parameters()
-
-    @property
-    def out_channels(self):
-        return self.hidden_channels
-
-    def forward(self, node_attr, pos, batch):
-        edge_index = radius_graph(pos, self.cutoff, batch=batch, loop=False)
-        edge_length = torch.norm(pos[edge_index[0]] - pos[edge_index[1]], dim=1)
-        edge_attr = self.distance_expansion(edge_length)
-        h = node_attr
-        for interaction in self.interactions:
-            h = h + interaction(h, edge_index, edge_length, edge_attr)
-        return h
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/models/backbones/regnet.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/models/backbones/regnet.py
deleted file mode 100644
index 91a602a952226cebb5fd0e3e282c6f98ae4fa455..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/models/backbones/regnet.py
+++ /dev/null
@@ -1,325 +0,0 @@
-import numpy as np
-import torch.nn as nn
-from mmcv.cnn import build_conv_layer, build_norm_layer
-
-from ..builder import BACKBONES
-from .resnet import ResNet
-from .resnext import Bottleneck
-
-
-@BACKBONES.register_module()
-class RegNet(ResNet):
-    """RegNet backbone.
-
-    More details can be found in `paper <https://arxiv.org/abs/2003.13678>`_ .
-
-    Args:
-        arch (dict): The parameter of RegNets.
-
-            - w0 (int): initial width
-            - wa (float): slope of width
-            - wm (float): quantization parameter to quantize the width
-            - depth (int): depth of the backbone
-            - group_w (int): width of group
-            - bot_mul (float): bottleneck ratio, i.e. expansion of bottleneck.
-        strides (Sequence[int]): Strides of the first block of each stage.
-        base_channels (int): Base channels after stem layer.
-        in_channels (int): Number of input image channels. Default: 3.
-        dilations (Sequence[int]): Dilation of each stage.
-        out_indices (Sequence[int]): Output from which stages.
-        style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two
-            layer is the 3x3 conv layer, otherwise the stride-two layer is
-            the first 1x1 conv layer.
-        frozen_stages (int): Stages to be frozen (all param fixed). -1 means
-            not freezing any parameters.
-        norm_cfg (dict): dictionary to construct and config norm layer.
-        norm_eval (bool): Whether to set norm layers to eval mode, namely,
-            freeze running stats (mean and var). Note: Effect on Batch Norm
-            and its variants only.
-        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
-            memory while slowing down the training speed.
-        zero_init_residual (bool): whether to use zero init for last norm layer
-            in resblocks to let them behave as identity.
-
-    Example:
-        >>> from mmdet.models import RegNet
-        >>> import torch
-        >>> self = RegNet(
-                arch=dict(
-                    w0=88,
-                    wa=26.31,
-                    wm=2.25,
-                    group_w=48,
-                    depth=25,
-                    bot_mul=1.0))
-        >>> self.eval()
-        >>> inputs = torch.rand(1, 3, 32, 32)
-        >>> level_outputs = self.forward(inputs)
-        >>> for level_out in level_outputs:
-        ...     print(tuple(level_out.shape))
-        (1, 96, 8, 8)
-        (1, 192, 4, 4)
-        (1, 432, 2, 2)
-        (1, 1008, 1, 1)
-    """
-    arch_settings = {
-        'regnetx_400mf':
-        dict(w0=24, wa=24.48, wm=2.54, group_w=16, depth=22, bot_mul=1.0),
-        'regnetx_800mf':
-        dict(w0=56, wa=35.73, wm=2.28, group_w=16, depth=16, bot_mul=1.0),
-        'regnetx_1.6gf':
-        dict(w0=80, wa=34.01, wm=2.25, group_w=24, depth=18, bot_mul=1.0),
-        'regnetx_3.2gf':
-        dict(w0=88, wa=26.31, wm=2.25, group_w=48, depth=25, bot_mul=1.0),
-        'regnetx_4.0gf':
-        dict(w0=96, wa=38.65, wm=2.43, group_w=40, depth=23, bot_mul=1.0),
-        'regnetx_6.4gf':
-        dict(w0=184, wa=60.83, wm=2.07, group_w=56, depth=17, bot_mul=1.0),
-        'regnetx_8.0gf':
-        dict(w0=80, wa=49.56, wm=2.88, group_w=120, depth=23, bot_mul=1.0),
-        'regnetx_12gf':
-        dict(w0=168, wa=73.36, wm=2.37, group_w=112, depth=19, bot_mul=1.0),
-    }
-
-    def __init__(self,
-                 arch,
-                 in_channels=3,
-                 stem_channels=32,
-                 base_channels=32,
-                 strides=(2, 2, 2, 2),
-                 dilations=(1, 1, 1, 1),
-                 out_indices=(0, 1, 2, 3),
-                 style='pytorch',
-                 deep_stem=False,
-                 avg_down=False,
-                 frozen_stages=-1,
-                 conv_cfg=None,
-                 norm_cfg=dict(type='BN', requires_grad=True),
-                 norm_eval=True,
-                 dcn=None,
-                 stage_with_dcn=(False, False, False, False),
-                 plugins=None,
-                 with_cp=False,
-                 zero_init_residual=True):
-        super(ResNet, self).__init__()
-
-        # Generate RegNet parameters first
-        if isinstance(arch, str):
-            assert arch in self.arch_settings, \
-                f'"arch": "{arch}" is not one of the' \
-                ' arch_settings'
-            arch = self.arch_settings[arch]
-        elif not isinstance(arch, dict):
-            raise ValueError('Expect "arch" to be either a string '
-                             f'or a dict, got {type(arch)}')
-
-        widths, num_stages = self.generate_regnet(
-            arch['w0'],
-            arch['wa'],
-            arch['wm'],
-            arch['depth'],
-        )
-        # Convert to per stage format
-        stage_widths, stage_blocks = self.get_stages_from_blocks(widths)
-        # Generate group widths and bot muls
-        group_widths = [arch['group_w'] for _ in range(num_stages)]
-        self.bottleneck_ratio = [arch['bot_mul'] for _ in range(num_stages)]
-        # Adjust the compatibility of stage_widths and group_widths
-        stage_widths, group_widths = self.adjust_width_group(
-            stage_widths, self.bottleneck_ratio, group_widths)
-
-        # Group params by stage
-        self.stage_widths = stage_widths
-        self.group_widths = group_widths
-        self.depth = sum(stage_blocks)
-        self.stem_channels = stem_channels
-        self.base_channels = base_channels
-        self.num_stages = num_stages
-        assert num_stages >= 1 and num_stages <= 4
-        self.strides = strides
-        self.dilations = dilations
-        assert len(strides) == len(dilations) == num_stages
-        self.out_indices = out_indices
-        assert max(out_indices) < num_stages
-        self.style = style
-        self.deep_stem = deep_stem
-        self.avg_down = avg_down
-        self.frozen_stages = frozen_stages
-        self.conv_cfg = conv_cfg
-        self.norm_cfg = norm_cfg
-        self.with_cp = with_cp
-        self.norm_eval = norm_eval
-        self.dcn = dcn
-        self.stage_with_dcn = stage_with_dcn
-        if dcn is not None:
-            assert len(stage_with_dcn) == num_stages
-        self.plugins = plugins
-        self.zero_init_residual = zero_init_residual
-        self.block = Bottleneck
-        expansion_bak = self.block.expansion
-        self.block.expansion = 1
-        self.stage_blocks = stage_blocks[:num_stages]
-
-        self._make_stem_layer(in_channels, stem_channels)
-
-        self.inplanes = stem_channels
-        self.res_layers = []
-        for i, num_blocks in enumerate(self.stage_blocks):
-            stride = self.strides[i]
-            dilation = self.dilations[i]
-            group_width = self.group_widths[i]
-            width = int(round(self.stage_widths[i] * self.bottleneck_ratio[i]))
-            stage_groups = width // group_width
-
-            dcn = self.dcn if self.stage_with_dcn[i] else None
-            if self.plugins is not None:
-                stage_plugins = self.make_stage_plugins(self.plugins, i)
-            else:
-                stage_plugins = None
-
-            res_layer = self.make_res_layer(
-                block=self.block,
-                inplanes=self.inplanes,
-                planes=self.stage_widths[i],
-                num_blocks=num_blocks,
-                stride=stride,
-                dilation=dilation,
-                style=self.style,
-                avg_down=self.avg_down,
-                with_cp=self.with_cp,
-                conv_cfg=self.conv_cfg,
-                norm_cfg=self.norm_cfg,
-                dcn=dcn,
-                plugins=stage_plugins,
-                groups=stage_groups,
-                base_width=group_width,
-                base_channels=self.stage_widths[i])
-            self.inplanes = self.stage_widths[i]
-            layer_name = f'layer{i + 1}'
-            self.add_module(layer_name, res_layer)
-            self.res_layers.append(layer_name)
-
-        self._freeze_stages()
-
-        self.feat_dim = stage_widths[-1]
-        self.block.expansion = expansion_bak
-
-    def _make_stem_layer(self, in_channels, base_channels):
-        self.conv1 = build_conv_layer(
-            self.conv_cfg,
-            in_channels,
-            base_channels,
-            kernel_size=3,
-            stride=2,
-            padding=1,
-            bias=False)
-        self.norm1_name, norm1 = build_norm_layer(
-            self.norm_cfg, base_channels, postfix=1)
-        self.add_module(self.norm1_name, norm1)
-        self.relu = nn.ReLU(inplace=True)
-
-    def generate_regnet(self,
-                        initial_width,
-                        width_slope,
-                        width_parameter,
-                        depth,
-                        divisor=8):
-        """Generates per block width from RegNet parameters.
-
-        Args:
-            initial_width ([int]): Initial width of the backbone
-            width_slope ([float]): Slope of the quantized linear function
-            width_parameter ([int]): Parameter used to quantize the width.
-            depth ([int]): Depth of the backbone.
-            divisor (int, optional): The divisor of channels. Defaults to 8.
-
-        Returns:
-            list, int: return a list of widths of each stage and the number \
-                of stages
-        """
-        assert width_slope >= 0
-        assert initial_width > 0
-        assert width_parameter > 1
-        assert initial_width % divisor == 0
-        widths_cont = np.arange(depth) * width_slope + initial_width
-        ks = np.round(
-            np.log(widths_cont / initial_width) / np.log(width_parameter))
-        widths = initial_width * np.power(width_parameter, ks)
-        widths = np.round(np.divide(widths, divisor)) * divisor
-        num_stages = len(np.unique(widths))
-        widths, widths_cont = widths.astype(int).tolist(), widths_cont.tolist()
-        return widths, num_stages
-
-    @staticmethod
-    def quantize_float(number, divisor):
-        """Converts a float to closest non-zero int divisible by divisor.
-
-        Args:
-            number (int): Original number to be quantized.
-            divisor (int): Divisor used to quantize the number.
-
-        Returns:
-            int: quantized number that is divisible by devisor.
-        """
-        return int(round(number / divisor) * divisor)
-
-    def adjust_width_group(self, widths, bottleneck_ratio, groups):
-        """Adjusts the compatibility of widths and groups.
-
-        Args:
-            widths (list[int]): Width of each stage.
-            bottleneck_ratio (float): Bottleneck ratio.
-            groups (int): number of groups in each stage
-
-        Returns:
-            tuple(list): The adjusted widths and groups of each stage.
-        """
-        bottleneck_width = [
-            int(w * b) for w, b in zip(widths, bottleneck_ratio)
-        ]
-        groups = [min(g, w_bot) for g, w_bot in zip(groups, bottleneck_width)]
-        bottleneck_width = [
-            self.quantize_float(w_bot, g)
-            for w_bot, g in zip(bottleneck_width, groups)
-        ]
-        widths = [
-            int(w_bot / b)
-            for w_bot, b in zip(bottleneck_width, bottleneck_ratio)
-        ]
-        return widths, groups
-
-    def get_stages_from_blocks(self, widths):
-        """Gets widths/stage_blocks of network at each stage.
-
-        Args:
-            widths (list[int]): Width in each stage.
-
-        Returns:
-            tuple(list): width and depth of each stage
-        """
-        width_diff = [
-            width != width_prev
-            for width, width_prev in zip(widths + [0], [0] + widths)
-        ]
-        stage_widths = [
-            width for width, diff in zip(widths, width_diff[:-1]) if diff
-        ]
-        stage_blocks = np.diff([
-            depth for depth, diff in zip(range(len(width_diff)), width_diff)
-            if diff
-        ]).tolist()
-        return stage_widths, stage_blocks
-
-    def forward(self, x):
-        """Forward function."""
-        x = self.conv1(x)
-        x = self.norm1(x)
-        x = self.relu(x)
-
-        outs = []
-        for i, layer_name in enumerate(self.res_layers):
-            res_layer = getattr(self, layer_name)
-            x = res_layer(x)
-            if i in self.out_indices:
-                outs.append(x)
-        return tuple(outs)
diff --git a/spaces/abidlabs/ControlNet/gradio_pose2image.py b/spaces/abidlabs/ControlNet/gradio_pose2image.py
deleted file mode 100644
index 1e6ce3aeec0584978dd66bc471c7295b2615a7c0..0000000000000000000000000000000000000000
--- a/spaces/abidlabs/ControlNet/gradio_pose2image.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# This file is adapted from https://github.com/lllyasviel/ControlNet/blob/f4748e3630d8141d7765e2bd9b1e348f47847707/gradio_pose2image.py
-# The original license file is LICENSE.ControlNet in this repo.
-import gradio as gr
-
-
-def create_demo(process, max_images=12):
-    with gr.Blocks() as demo:
-        with gr.Row():
-            gr.Markdown('## Control Stable Diffusion with Human Pose')
-        with gr.Row():
-            with gr.Column():
-                input_image = gr.Image(source='upload', type='numpy')
-                prompt = gr.Textbox(label='Prompt')
-                run_button = gr.Button(label='Run')
-                with gr.Accordion('Advanced options', open=False):
-                    num_samples = gr.Slider(label='Images',
-                                            minimum=1,
-                                            maximum=max_images,
-                                            value=1,
-                                            step=1)
-                    image_resolution = gr.Slider(label='Image Resolution',
-                                                 minimum=256,
-                                                 maximum=768,
-                                                 value=512,
-                                                 step=256)
-                    detect_resolution = gr.Slider(label='OpenPose Resolution',
-                                                  minimum=128,
-                                                  maximum=1024,
-                                                  value=512,
-                                                  step=1)
-                    ddim_steps = gr.Slider(label='Steps',
-                                           minimum=1,
-                                           maximum=100,
-                                           value=20,
-                                           step=1)
-                    scale = gr.Slider(label='Guidance Scale',
-                                      minimum=0.1,
-                                      maximum=30.0,
-                                      value=9.0,
-                                      step=0.1)
-                    seed = gr.Slider(label='Seed',
-                                     minimum=-1,
-                                     maximum=2147483647,
-                                     step=1,
-                                     randomize=True,
-                                     queue=False)
-                    eta = gr.Number(label='eta (DDIM)', value=0.0)
-                    a_prompt = gr.Textbox(
-                        label='Added Prompt',
-                        value='best quality, extremely detailed')
-                    n_prompt = gr.Textbox(
-                        label='Negative Prompt',
-                        value=
-                        'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality'
-                    )
-            with gr.Column():
-                result_gallery = gr.Gallery(label='Output',
-                                            show_label=False,
-                                            elem_id='gallery').style(
-                                                grid=2, height='auto')
-        ips = [
-            input_image, prompt, a_prompt, n_prompt, num_samples,
-            image_resolution, detect_resolution, ddim_steps, scale, seed, eta
-        ]
-        run_button.click(fn=process,
-                         inputs=ips,
-                         outputs=[result_gallery],
-                         api_name='pose')
-    return demo
diff --git a/spaces/abrar-lohia/text-2-character-anim/pyrender/.eggs/pyglet-2.0.5-py3.10.egg/pyglet/graphics/__init__.py b/spaces/abrar-lohia/text-2-character-anim/pyrender/.eggs/pyglet-2.0.5-py3.10.egg/pyglet/graphics/__init__.py
deleted file mode 100644
index 972a126647d9a2e8d4dd936b7467f1ccd162170c..0000000000000000000000000000000000000000
--- a/spaces/abrar-lohia/text-2-character-anim/pyrender/.eggs/pyglet-2.0.5-py3.10.egg/pyglet/graphics/__init__.py
+++ /dev/null
@@ -1,638 +0,0 @@
-"""Low-level graphics rendering and abstractions.
-
-This module provides efficient abstractions over OpenGL objects, such as
-Shaders and Buffers. It also provides classes for highly performant batched
-rendering and grouping.
-
-See the :ref:`guide_graphics` for details on how to use this graphics API.
-"""
-
-import ctypes
-import weakref
-
-import pyglet
-from pyglet.gl import *
-from pyglet.graphics import shader, vertexdomain
-from pyglet.graphics.vertexarray import VertexArray
-from pyglet.graphics.vertexbuffer import BufferObject
-
-_debug_graphics_batch = pyglet.options['debug_graphics_batch']
-
-
-def draw(size, mode, **data):
-    """Draw a primitive immediately.
-
-    :warning: This function is deprecated as of 2.0.4, and will be removed
-              in the next release.
-
-    :Parameters:
-        `size` : int
-            Number of vertices given
-        `mode` : gl primitive type 
-            OpenGL drawing mode, e.g. ``GL_TRIANGLES``, 
-            avoiding quotes.
-        `**data` : keyword arguments for passing vertex attribute data.
-            The keyword should be the vertex attribute name, and the
-            argument should be a tuple of (format, data). For example:
-            `position=('f', array)`
-
-    """
-    # Create and bind a throwaway VAO
-    vao_id = GLuint()
-    glGenVertexArrays(1, vao_id)
-    glBindVertexArray(vao_id)
-    # Activate shader program:
-    program = get_default_shader()
-    program.use()
-
-    buffers = []
-    for name, (fmt, array) in data.items():
-        location = program.attributes[name]['location']
-        count = program.attributes[name]['count']
-        gl_type = vertexdomain._gl_types[fmt[0]]
-        normalize = 'n' in fmt
-        attribute = shader.Attribute(name, location, count, gl_type, normalize)
-        assert size == len(array) // attribute.count, 'Data for %s is incorrect length' % fmt
-
-        buffer = BufferObject(size * attribute.stride)
-        attribute.set_region(buffer, 0, size, array)
-        attribute.enable()
-        attribute.set_pointer(buffer.ptr)
-
-        buffers.append(buffer)      # Don't garbage collect it.
-
-    glDrawArrays(mode, 0, size)
-
-    # Deactivate shader program:
-    program.stop()
-    # Discard everything after drawing:
-    del buffers
-    glBindVertexArray(0)
-    glDeleteVertexArrays(1, vao_id)
-
-
-def draw_indexed(size, mode, indices, **data):
-    """Draw a primitive with indexed vertices immediately.
-
-    :warning: This function is deprecated as of 2.0.4, and will be removed
-              in the next release.
-
-    :Parameters:
-        `size` : int
-            Number of vertices given
-        `mode` : int
-            OpenGL drawing mode, e.g. ``GL_TRIANGLES``
-        `indices` : sequence of int
-            Sequence of integers giving indices into the vertex list.
-        `**data` : keyword arguments for passing vertex attribute data.
-            The keyword should be the vertex attribute name, and the
-            argument should be a tuple of (format, data). For example:
-            `position=('f', array)`
-
-    """
-    # Create and bind a throwaway VAO
-    vao_id = GLuint()
-    glGenVertexArrays(1, vao_id)
-    glBindVertexArray(vao_id)
-    # Activate shader program:
-    program = get_default_shader()
-    program.use()
-
-    buffers = []
-    for name, (fmt, array) in data.items():
-        location = program.attributes[name]['location']
-        count = program.attributes[name]['count']
-        gl_type = vertexdomain._gl_types[fmt[0]]
-        normalize = 'n' in fmt
-        attribute = shader.Attribute(name, location, count, gl_type, normalize)
-        assert size == len(array) // attribute.count, 'Data for %s is incorrect length' % fmt
-
-        buffer = BufferObject(size * attribute.stride)
-        attribute.set_region(buffer, 0, size, array)
-        attribute.enable()
-        attribute.set_pointer(buffer.ptr)
-        buffers.append(buffer)
-
-    if size <= 0xff:
-        index_type = GL_UNSIGNED_BYTE
-        index_c_type = ctypes.c_ubyte
-    elif size <= 0xffff:
-        index_type = GL_UNSIGNED_SHORT
-        index_c_type = ctypes.c_ushort
-    else:
-        index_type = GL_UNSIGNED_INT
-        index_c_type = ctypes.c_uint
-
-    # With GL 3.3 vertex arrays indices needs to be in a buffer
-    # bound to the ELEMENT_ARRAY slot
-    index_array = (index_c_type * len(indices))(*indices)
-    index_buffer = BufferObject(ctypes.sizeof(index_array))
-    index_buffer.set_data(index_array)
-    index_buffer.bind_to_index_buffer()
-
-    glDrawElements(mode, len(indices), index_type, 0)
-    glFlush()
-
-    # Deactivate shader program:
-    program.stop()
-    # Discard everything after drawing:
-    del buffers
-    del index_buffer
-    glBindVertexArray(0)
-    glDeleteVertexArrays(1, vao_id)
-
-
-# Default Shader source:
-
-_vertex_source = """#version 330 core
-    in vec3 position;
-    in vec4 colors;
-    in vec3 tex_coords;
-    out vec4 vertex_colors;
-    out vec3 texture_coords;
-
-    uniform WindowBlock
-    {
-        mat4 projection;
-        mat4 view;
-    } window;  
-
-    void main()
-    {
-        gl_Position = window.projection * window.view * vec4(position, 1.0);
-
-        vertex_colors = colors;
-        texture_coords = tex_coords;
-    }
-"""
-
-_fragment_source = """#version 330 core
-    in vec4 vertex_colors;
-    in vec3 texture_coords;
-    out vec4 final_colors;
-
-    uniform sampler2D our_texture;
-
-    void main()
-    {
-        final_colors = texture(our_texture, texture_coords.xy) + vertex_colors;
-    }
-"""
-
-
-def get_default_batch():
-    try:
-        return pyglet.gl.current_context.pyglet_graphics_default_batch
-    except AttributeError:
-        pyglet.gl.current_context.pyglet_graphics_default_batch = Batch()
-        return pyglet.gl.current_context.pyglet_graphics_default_batch
-
-
-def get_default_group():
-    try:
-        return pyglet.gl.current_context.pyglet_graphics_default_group
-    except AttributeError:
-        pyglet.gl.current_context.pyglet_graphics_default_group = ShaderGroup(get_default_shader())
-        return pyglet.gl.current_context.pyglet_graphics_default_group
-
-
-def get_default_shader():
-    try:
-        return pyglet.gl.current_context.pyglet_graphics_default_shader
-    except AttributeError:
-        _default_vert_shader = pyglet.graphics.shader.Shader(_vertex_source, 'vertex')
-        _default_frag_shader = pyglet.graphics.shader.Shader(_fragment_source, 'fragment')
-        default_shader_program = pyglet.graphics.shader.ShaderProgram(_default_vert_shader, _default_frag_shader)
-        pyglet.gl.current_context.pyglet_graphics_default_shader = default_shader_program
-        return pyglet.gl.current_context.pyglet_graphics_default_shader
-
-
-class Batch:
-    """Manage a collection of drawables for batched rendering.
-
-    Many drawable pyglet objects accept an optional `Batch` argument in their
-    constructors. By giving a `Batch` to multiple objects, you can tell pyglet
-    that you expect to draw all of these objects at once, so it can optimise its
-    use of OpenGL. Hence, drawing a `Batch` is often much faster than drawing
-    each contained drawable separately.
-
-    The following example creates a batch, adds two sprites to the batch, and
-    then draws the entire batch::
-
-        batch = pyglet.graphics.Batch()
-        car = pyglet.sprite.Sprite(car_image, batch=batch)
-        boat = pyglet.sprite.Sprite(boat_image, batch=batch)
-
-        def on_draw():
-            batch.draw()
-
-    While any drawables can be added to a `Batch`, only those with the same
-    draw mode, shader program, and group can be optimised together.
-
-    Internally, a `Batch` manages a set of VertexDomains along with
-    information about how the domains are to be drawn. To implement batching on
-    a custom drawable, get your vertex domains from the given batch instead of
-    setting them up yourself.
-    """
-
-    def __init__(self):
-        """Create a graphics batch."""
-        # Mapping to find domain.  
-        # group -> (attributes, mode, indexed) -> domain
-        self.group_map = {}
-
-        # Mapping of group to list of children.
-        self.group_children = {}
-
-        # List of top-level groups
-        self.top_groups = []
-
-        self._draw_list = []
-        self._draw_list_dirty = False
-
-        self._context = pyglet.gl.current_context
-
-    def invalidate(self):
-        """Force the batch to update the draw list.
-
-        This method can be used to force the batch to re-compute the draw list
-        when the ordering of groups has changed.
-
-        .. versionadded:: 1.2
-        """
-        self._draw_list_dirty = True
-
-    def migrate(self, vertex_list, mode, group, batch):
-        """Migrate a vertex list to another batch and/or group.
-
-        `vertex_list` and `mode` together identify the vertex list to migrate.
-        `group` and `batch` are new owners of the vertex list after migration.  
-
-        The results are undefined if `mode` is not correct or if `vertex_list`
-        does not belong to this batch (they are not checked and will not
-        necessarily throw an exception immediately).
-
-        `batch` can remain unchanged if only a group change is desired.
-        
-        :Parameters:
-            `vertex_list` : `~pyglet.graphics.vertexdomain.VertexList`
-                A vertex list currently belonging to this batch.
-            `mode` : int
-                The current GL drawing mode of the vertex list.
-            `group` : `~pyglet.graphics.Group`
-                The new group to migrate to.
-            `batch` : `~pyglet.graphics.Batch`
-                The batch to migrate to (or the current batch).
-
-        """
-        program = vertex_list.domain.program
-        attributes = vertex_list.domain.attribute_meta
-        if isinstance(vertex_list, vertexdomain.IndexedVertexList):
-            domain = batch.get_domain(True, mode, group, program, attributes)
-        else:
-            domain = batch.get_domain(False, mode, group, program, attributes)
-        vertex_list.migrate(domain)
-
-    def get_domain(self, indexed, mode, group, program, attributes):
-        """Get, or create, the vertex domain corresponding to the given arguments."""
-        if group is None:
-            group = ShaderGroup(program=program)
-
-        # Batch group
-        if group not in self.group_map:
-            self._add_group(group)
-
-        # Find domain given formats, indices and mode
-        domain_map = self.group_map[group]
-        key = (indexed, mode, program, str(attributes))
-        try:
-            domain = domain_map[key]
-        except KeyError:
-            # Create domain
-            if indexed:
-                domain = vertexdomain.IndexedVertexDomain(program, attributes)
-            else:
-                domain = vertexdomain.VertexDomain(program, attributes)
-            domain_map[key] = domain
-            self._draw_list_dirty = True
-
-        return domain
-
-    def _add_group(self, group):
-        self.group_map[group] = {}
-        if group.parent is None:
-            self.top_groups.append(group)
-        else:
-            if group.parent not in self.group_map:
-                self._add_group(group.parent)
-            if group.parent not in self.group_children:
-                self.group_children[group.parent] = []
-            self.group_children[group.parent].append(group)
-
-        group._assigned_batches.add(self)
-        self._draw_list_dirty = True
-
-    def _update_draw_list(self):
-        """Visit group tree in preorder and create a list of bound methods
-        to call.
-        """
-
-        def visit(group):
-            draw_list = []
-
-            # Draw domains using this group
-            domain_map = self.group_map[group]
-            for (formats, mode, indexed, program_id), domain in list(domain_map.items()):
-                # Remove unused domains from batch
-                if domain.is_empty:
-                    del domain_map[(formats, mode, indexed, program_id)]
-                    continue
-                draw_list.append((lambda d, m: lambda: d.draw(m))(domain, mode))
-
-            # Sort and visit child groups of this group
-            children = self.group_children.get(group)
-            if children:
-                children.sort()
-                for child in list(children):
-                    if child.visible:
-                        draw_list.extend(visit(child))
-
-            if children or domain_map:
-                return [group.set_state] + draw_list + [group.unset_state]
-            else:
-                # Remove unused group from batch
-                del self.group_map[group]
-                group._assigned_batches.remove(self)
-                if group.parent:
-                    self.group_children[group.parent].remove(group)
-                try:
-                    del self.group_children[group]
-                except KeyError:
-                    pass
-                try:
-                    self.top_groups.remove(group)
-                except ValueError:
-                    pass
-
-                return []
-
-        self._draw_list = []
-
-        self.top_groups.sort()
-        for group in list(self.top_groups):
-            if group.visible:
-                self._draw_list.extend(visit(group))
-
-        self._draw_list_dirty = False
-
-        if _debug_graphics_batch:
-            self._dump_draw_list()
-
-    def _dump_draw_list(self):
-        def dump(group, indent=''):
-            print(indent, 'Begin group', group)
-            domain_map = self.group_map[group]
-            for _, domain in domain_map.items():
-                print(indent, '  ', domain)
-                for start, size in zip(*domain.allocator.get_allocated_regions()):
-                    print(indent, '    ', 'Region %d size %d:' % (start, size))
-                    for key, attribute in domain.attribute_names.items():
-                        print(indent, '      ', end=' ')
-                        try:
-                            region = attribute.get_region(attribute.buffer, start, size)
-                            print(key, region.array[:])
-                        except:
-                            print(key, '(unmappable)')
-            for child in self.group_children.get(group, ()):
-                dump(child, indent + '  ')
-            print(indent, 'End group', group)
-
-        print('Draw list for %r:' % self)
-        for group in self.top_groups:
-            dump(group)
-
-    def draw(self):
-        """Draw the batch."""
-
-        if self._draw_list_dirty:
-            self._update_draw_list()
-
-        for func in self._draw_list:
-            func()
-
-    def draw_subset(self, vertex_lists):
-        """Draw only some vertex lists in the batch.
-
-        The use of this method is highly discouraged, as it is quite
-        inefficient.  Usually an application can be redesigned so that batches
-        can always be drawn in their entirety, using `draw`.
-
-        The given vertex lists must belong to this batch; behaviour is
-        undefined if this condition is not met.
-
-        :Parameters:
-            `vertex_lists` : sequence of `VertexList` or `IndexedVertexList`
-                Vertex lists to draw.
-
-        """
-
-        # Horrendously inefficient.
-        def visit(group):
-            group.set_state()
-
-            # Draw domains using this group
-            domain_map = self.group_map[group]
-            for (_, mode, _, _), domain in domain_map.items():
-                for alist in vertex_lists:
-                    if alist.domain is domain:
-                        alist.draw(mode)
-
-            # Sort and visit child groups of this group
-            children = self.group_children.get(group)
-            if children:
-                children.sort()
-                for child in children:
-                    if child.visible:
-                        visit(child)
-
-            group.unset_state()
-
-        self.top_groups.sort()
-        for group in self.top_groups:
-            if group.visible:
-                visit(group)
-
-
-class Group:
-    """Group of common OpenGL state.
-
-    `Group` provides extra control over how drawables are handled within a
-    `Batch`. When a batch draws a drawable, it ensures its group's state is set;
-    this can include binding textures, shaders, or setting any other parameters.
-    It also sorts the groups before drawing.
-
-    In the following example, the background sprite is guaranteed to be drawn
-    before the car and the boat::
-
-        batch = pyglet.graphics.Batch()
-        background = pyglet.graphics.Group(order=0)
-        foreground = pyglet.graphics.Group(order=1)
-
-        background = pyglet.sprite.Sprite(background_image, batch=batch, group=background)
-        car = pyglet.sprite.Sprite(car_image, batch=batch, group=foreground)
-        boat = pyglet.sprite.Sprite(boat_image, batch=batch, group=foreground)
-
-        def on_draw():
-            batch.draw()
-
-    :Parameters:
-        `order` : int
-            Set the order to render above or below other Groups.
-            Lower orders are drawn first.
-        `parent` : `~pyglet.graphics.Group`
-            Group to contain this Group; its state will be set before this
-            Group's state.
-
-    :Variables:
-        `visible` : bool
-            Determines whether this Group is visible in any of the Batches
-            it is assigned to. If ``False``, objects in this Group will not
-            be rendered.
-        `batches` : list
-            Read Only. A list of which Batches this Group is a part of.
-    """
-    def __init__(self, order=0, parent=None):
-
-        self._order = order
-        self.parent = parent
-        self._visible = True
-        self._assigned_batches = weakref.WeakSet()
-
-    @property
-    def order(self):
-        return self._order
-
-    @property
-    def visible(self):
-        return self._visible
-
-    @visible.setter
-    def visible(self, value):
-        self._visible = value
-
-        for batch in self._assigned_batches:
-            batch.invalidate()
-
-    @property
-    def batches(self):
-        return [batch for batch in self._assigned_batches]
-
-    def __lt__(self, other):
-        return self._order < other.order
-
-    def __eq__(self, other):
-        return (self.__class__ is other.__class__ and
-                self._order == other.order and
-                self.parent == other.parent)
-
-    def __hash__(self):
-        return hash((self._order, self.parent))
-
-    def __repr__(self):
-        return "{}(order={})".format(self.__class__.__name__, self._order)
-
-    def set_state(self):
-        """Apply the OpenGL state change.
-        
-        The default implementation does nothing."""
-        pass
-
-    def unset_state(self):
-        """Repeal the OpenGL state change.
-        
-        The default implementation does nothing."""
-        pass
-
-    def set_state_recursive(self):
-        """Set this group and its ancestry.
-
-        Call this method if you are using a group in isolation: the
-        parent groups will be called in top-down order, with this class's
-        `set` being called last.
-        """
-        if self.parent:
-            self.parent.set_state_recursive()
-        self.set_state()
-
-    def unset_state_recursive(self):
-        """Unset this group and its ancestry.
-
-        The inverse of `set_state_recursive`.
-        """
-        self.unset_state()
-        if self.parent:
-            self.parent.unset_state_recursive()
-
-
-# Example Groups.
-
-class ShaderGroup(Group):
-    """A group that enables and binds a ShaderProgram.
-    """
-
-    def __init__(self, program, order=0, parent=None):
-        super().__init__(order, parent)
-        self.program = program
-
-    def set_state(self):
-        self.program.use()
-
-    def unset_state(self):
-        self.program.stop()
-
-    def __eq__(self, other):
-        return (self.__class__ is other.__class__ and
-                self._order == other.order and
-                self.program == other.program and
-                self.parent == other.parent)
-
-    def __hash__(self):
-        return hash((self._order, self.parent, self.program))
-
-
-class TextureGroup(Group):
-    """A group that enables and binds a texture.
-
-    TextureGroups are equal if their textures' targets and names are equal.
-    """
-
-    def __init__(self, texture, order=0, parent=None):
-        """Create a texture group.
-
-        :Parameters:
-            `texture` : `~pyglet.image.Texture`
-                Texture to bind.
-            `order` : int
-                Change the order to render above or below other Groups.
-            `parent` : `~pyglet.graphics.Group`
-                Parent group.
-        """
-        super().__init__(order, parent)
-        self.texture = texture
-
-    def set_state(self):
-        glActiveTexture(GL_TEXTURE0)
-        glBindTexture(self.texture.target, self.texture.id)
-
-    def __hash__(self):
-        return hash((self.texture.target, self.texture.id, self.order, self.parent))
-
-    def __eq__(self, other):
-        return (self.__class__ is other.__class__ and
-                self.texture.target == other.texture.target and
-                self.texture.id == other.texture.id and
-                self.order == other.order and
-                self.parent == other.parent)
-
-    def __repr__(self):
-        return '%s(id=%d)' % (self.__class__.__name__, self.texture.id)
diff --git a/spaces/adorp/ControlNet-v1-1-duplicate/app_ip2p.py b/spaces/adorp/ControlNet-v1-1-duplicate/app_ip2p.py
deleted file mode 100644
index 6ba543bab553a249e121657fae1baf1b4c41a5e3..0000000000000000000000000000000000000000
--- a/spaces/adorp/ControlNet-v1-1-duplicate/app_ip2p.py
+++ /dev/null
@@ -1,94 +0,0 @@
-#!/usr/bin/env python
-
-import gradio as gr
-
-from utils import randomize_seed_fn
-
-
-def create_demo(process, max_images=12, default_num_images=3):
-    with gr.Blocks() as demo:
-        with gr.Row():
-            with gr.Column():
-                image = gr.Image()
-                prompt = gr.Textbox(label='Prompt')
-                run_button = gr.Button('Run')
-                with gr.Accordion('Advanced options', open=False):
-                    num_samples = gr.Slider(label='Number of images',
-                                            minimum=1,
-                                            maximum=max_images,
-                                            value=default_num_images,
-                                            step=1)
-                    image_resolution = gr.Slider(label='Image resolution',
-                                                 minimum=256,
-                                                 maximum=512,
-                                                 value=512,
-                                                 step=256)
-                    num_steps = gr.Slider(label='Number of steps',
-                                          minimum=1,
-                                          maximum=100,
-                                          value=20,
-                                          step=1)
-                    guidance_scale = gr.Slider(label='Guidance scale',
-                                               minimum=0.1,
-                                               maximum=30.0,
-                                               value=9.0,
-                                               step=0.1)
-                    seed = gr.Slider(label='Seed',
-                                     minimum=0,
-                                     maximum=1000000,
-                                     step=1,
-                                     value=0,
-                                     randomize=True)
-                    randomize_seed = gr.Checkbox(label='Randomize seed',
-                                                 value=True)
-                    a_prompt = gr.Textbox(
-                        label='Additional prompt',
-                        value='best quality, extremely detailed')
-                    n_prompt = gr.Textbox(
-                        label='Negative prompt',
-                        value=
-                        'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality'
-                    )
-            with gr.Column():
-                result = gr.Gallery(label='Output', show_label=False).style(
-                    columns=2, object_fit='scale-down')
-        inputs = [
-            image,
-            prompt,
-            a_prompt,
-            n_prompt,
-            num_samples,
-            image_resolution,
-            num_steps,
-            guidance_scale,
-            seed,
-        ]
-        prompt.submit(
-            fn=randomize_seed_fn,
-            inputs=[seed, randomize_seed],
-            outputs=seed,
-            queue=False,
-        ).then(
-            fn=process,
-            inputs=inputs,
-            outputs=result,
-        )
-        run_button.click(
-            fn=randomize_seed_fn,
-            inputs=[seed, randomize_seed],
-            outputs=seed,
-            queue=False,
-        ).then(
-            fn=process,
-            inputs=inputs,
-            outputs=result,
-            api_name='ip2p',
-        )
-    return demo
-
-
-if __name__ == '__main__':
-    from model import Model
-    model = Model(task_name='ip2p')
-    demo = create_demo(model.process_ip2p)
-    demo.queue().launch()
diff --git a/spaces/akhaliq/lama/saicinpainting/evaluation/evaluator.py b/spaces/akhaliq/lama/saicinpainting/evaluation/evaluator.py
deleted file mode 100644
index aa9e80402633c08a580929b38a5cb695cb7171d8..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/lama/saicinpainting/evaluation/evaluator.py
+++ /dev/null
@@ -1,220 +0,0 @@
-import logging
-import math
-from typing import Dict
-
-import numpy as np
-import torch
-import torch.nn as nn
-import tqdm
-from torch.utils.data import DataLoader
-
-from saicinpainting.evaluation.utils import move_to_device
-
-LOGGER = logging.getLogger(__name__)
-
-
-class InpaintingEvaluator():
-    def __init__(self, dataset, scores, area_grouping=True, bins=10, batch_size=32, device='cuda',
-                 integral_func=None, integral_title=None, clamp_image_range=None):
-        """
-        :param dataset: torch.utils.data.Dataset which contains images and masks
-        :param scores: dict {score_name: EvaluatorScore object}
-        :param area_grouping: in addition to the overall scores, allows to compute score for the groups of samples
-            which are defined by share of area occluded by mask
-        :param bins: number of groups, partition is generated by np.linspace(0., 1., bins + 1)
-        :param batch_size: batch_size for the dataloader
-        :param device: device to use
-        """
-        self.scores = scores
-        self.dataset = dataset
-
-        self.area_grouping = area_grouping
-        self.bins = bins
-
-        self.device = torch.device(device)
-
-        self.dataloader = DataLoader(self.dataset, shuffle=False, batch_size=batch_size)
-
-        self.integral_func = integral_func
-        self.integral_title = integral_title
-        self.clamp_image_range = clamp_image_range
-
-    def _get_bin_edges(self):
-        bin_edges = np.linspace(0, 1, self.bins + 1)
-
-        num_digits = max(0, math.ceil(math.log10(self.bins)) - 1)
-        interval_names = []
-        for idx_bin in range(self.bins):
-            start_percent, end_percent = round(100 * bin_edges[idx_bin], num_digits), \
-                                         round(100 * bin_edges[idx_bin + 1], num_digits)
-            start_percent = '{:.{n}f}'.format(start_percent, n=num_digits)
-            end_percent = '{:.{n}f}'.format(end_percent, n=num_digits)
-            interval_names.append("{0}-{1}%".format(start_percent, end_percent))
-
-        groups = []
-        for batch in self.dataloader:
-            mask = batch['mask']
-            batch_size = mask.shape[0]
-            area = mask.to(self.device).reshape(batch_size, -1).mean(dim=-1)
-            bin_indices = np.searchsorted(bin_edges, area.detach().cpu().numpy(), side='right') - 1
-            # corner case: when area is equal to 1, bin_indices should return bins - 1, not bins for that element
-            bin_indices[bin_indices == self.bins] = self.bins - 1
-            groups.append(bin_indices)
-        groups = np.hstack(groups)
-
-        return groups, interval_names
-
-    def evaluate(self, model=None):
-        """
-        :param model: callable with signature (image_batch, mask_batch); should return inpainted_batch
-        :return: dict with (score_name, group_type) as keys, where group_type can be either 'overall' or
-            name of the particular group arranged by area of mask (e.g. '10-20%')
-            and score statistics for the group as values.
-        """
-        results = dict()
-        if self.area_grouping:
-            groups, interval_names = self._get_bin_edges()
-        else:
-            groups = None
-
-        for score_name, score in tqdm.auto.tqdm(self.scores.items(), desc='scores'):
-            score.to(self.device)
-            with torch.no_grad():
-                score.reset()
-                for batch in tqdm.auto.tqdm(self.dataloader, desc=score_name, leave=False):
-                    batch = move_to_device(batch, self.device)
-                    image_batch, mask_batch = batch['image'], batch['mask']
-                    if self.clamp_image_range is not None:
-                        image_batch = torch.clamp(image_batch,
-                                                  min=self.clamp_image_range[0],
-                                                  max=self.clamp_image_range[1])
-                    if model is None:
-                        assert 'inpainted' in batch, \
-                            'Model is None, so we expected precomputed inpainting results at key "inpainted"'
-                        inpainted_batch = batch['inpainted']
-                    else:
-                        inpainted_batch = model(image_batch, mask_batch)
-                    score(inpainted_batch, image_batch, mask_batch)
-                total_results, group_results = score.get_value(groups=groups)
-
-            results[(score_name, 'total')] = total_results
-            if groups is not None:
-                for group_index, group_values in group_results.items():
-                    group_name = interval_names[group_index]
-                    results[(score_name, group_name)] = group_values
-
-        if self.integral_func is not None:
-            results[(self.integral_title, 'total')] = dict(mean=self.integral_func(results))
-
-        return results
-
-
-def ssim_fid100_f1(metrics, fid_scale=100):
-    ssim = metrics[('ssim', 'total')]['mean']
-    fid = metrics[('fid', 'total')]['mean']
-    fid_rel = max(0, fid_scale - fid) / fid_scale
-    f1 = 2 * ssim * fid_rel / (ssim + fid_rel + 1e-3)
-    return f1
-
-
-def lpips_fid100_f1(metrics, fid_scale=100):
-    neg_lpips = 1 - metrics[('lpips', 'total')]['mean']  # invert, so bigger is better
-    fid = metrics[('fid', 'total')]['mean']
-    fid_rel = max(0, fid_scale - fid) / fid_scale
-    f1 = 2 * neg_lpips * fid_rel / (neg_lpips + fid_rel + 1e-3)
-    return f1
-
-
-
-class InpaintingEvaluatorOnline(nn.Module):
-    def __init__(self, scores, bins=10, image_key='image', inpainted_key='inpainted',
-                 integral_func=None, integral_title=None, clamp_image_range=None):
-        """
-        :param scores: dict {score_name: EvaluatorScore object}
-        :param bins: number of groups, partition is generated by np.linspace(0., 1., bins + 1)
-        :param device: device to use
-        """
-        super().__init__()
-        LOGGER.info(f'{type(self)} init called')
-        self.scores = nn.ModuleDict(scores)
-        self.image_key = image_key
-        self.inpainted_key = inpainted_key
-        self.bins_num = bins
-        self.bin_edges = np.linspace(0, 1, self.bins_num + 1)
-
-        num_digits = max(0, math.ceil(math.log10(self.bins_num)) - 1)
-        self.interval_names = []
-        for idx_bin in range(self.bins_num):
-            start_percent, end_percent = round(100 * self.bin_edges[idx_bin], num_digits), \
-                                         round(100 * self.bin_edges[idx_bin + 1], num_digits)
-            start_percent = '{:.{n}f}'.format(start_percent, n=num_digits)
-            end_percent = '{:.{n}f}'.format(end_percent, n=num_digits)
-            self.interval_names.append("{0}-{1}%".format(start_percent, end_percent))
-
-        self.groups = []
-
-        self.integral_func = integral_func
-        self.integral_title = integral_title
-        self.clamp_image_range = clamp_image_range
-
-        LOGGER.info(f'{type(self)} init done')
-
-    def _get_bins(self, mask_batch):
-        batch_size = mask_batch.shape[0]
-        area = mask_batch.view(batch_size, -1).mean(dim=-1).detach().cpu().numpy()
-        bin_indices = np.clip(np.searchsorted(self.bin_edges, area) - 1, 0, self.bins_num - 1)
-        return bin_indices
-
-    def forward(self, batch: Dict[str, torch.Tensor]):
-        """
-        Calculate and accumulate metrics for batch. To finalize evaluation and obtain final metrics, call evaluation_end
-        :param batch: batch dict with mandatory fields mask, image, inpainted (can be overriden by self.inpainted_key)
-        """
-        result = {}
-        with torch.no_grad():
-            image_batch, mask_batch, inpainted_batch = batch[self.image_key], batch['mask'], batch[self.inpainted_key]
-            if self.clamp_image_range is not None:
-                image_batch = torch.clamp(image_batch,
-                                          min=self.clamp_image_range[0],
-                                          max=self.clamp_image_range[1])
-            self.groups.extend(self._get_bins(mask_batch))
-
-            for score_name, score in self.scores.items():
-                result[score_name] = score(inpainted_batch, image_batch, mask_batch)
-        return result
-
-    def process_batch(self, batch: Dict[str, torch.Tensor]):
-        return self(batch)
-
-    def evaluation_end(self, states=None):
-        """:return: dict with (score_name, group_type) as keys, where group_type can be either 'overall' or
-            name of the particular group arranged by area of mask (e.g. '10-20%')
-            and score statistics for the group as values.
-        """
-        LOGGER.info(f'{type(self)}: evaluation_end called')
-
-        self.groups = np.array(self.groups)
-
-        results = {}
-        for score_name, score in self.scores.items():
-            LOGGER.info(f'Getting value of {score_name}')
-            cur_states = [s[score_name] for s in states] if states is not None else None
-            total_results, group_results = score.get_value(groups=self.groups, states=cur_states)
-            LOGGER.info(f'Getting value of {score_name} done')
-            results[(score_name, 'total')] = total_results
-
-            for group_index, group_values in group_results.items():
-                group_name = self.interval_names[group_index]
-                results[(score_name, group_name)] = group_values
-
-        if self.integral_func is not None:
-            results[(self.integral_title, 'total')] = dict(mean=self.integral_func(results))
-
-        LOGGER.info(f'{type(self)}: reset scores')
-        self.groups = []
-        for sc in self.scores.values():
-            sc.reset()
-        LOGGER.info(f'{type(self)}: reset scores done')
-
-        LOGGER.info(f'{type(self)}: evaluation_end done')
-        return results
diff --git a/spaces/akhaliq/lama/saicinpainting/training/visualizers/base.py b/spaces/akhaliq/lama/saicinpainting/training/visualizers/base.py
deleted file mode 100644
index 675f01682ddf5e31b6cc341735378c6f3b242e49..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/lama/saicinpainting/training/visualizers/base.py
+++ /dev/null
@@ -1,73 +0,0 @@
-import abc
-from typing import Dict, List
-
-import numpy as np
-import torch
-from skimage import color
-from skimage.segmentation import mark_boundaries
-
-from . import colors
-
-COLORS, _ = colors.generate_colors(151) # 151 - max classes for semantic segmentation
-
-
-class BaseVisualizer:
-    @abc.abstractmethod
-    def __call__(self, epoch_i, batch_i, batch, suffix='', rank=None):
-        """
-        Take a batch, make an image from it and visualize
-        """
-        raise NotImplementedError()
-
-
-def visualize_mask_and_images(images_dict: Dict[str, np.ndarray], keys: List[str],
-                              last_without_mask=True, rescale_keys=None, mask_only_first=None,
-                              black_mask=False) -> np.ndarray:
-    mask = images_dict['mask'] > 0.5
-    result = []
-    for i, k in enumerate(keys):
-        img = images_dict[k]
-        img = np.transpose(img, (1, 2, 0))
-
-        if rescale_keys is not None and k in rescale_keys:
-            img = img - img.min()
-            img /= img.max() + 1e-5
-        if len(img.shape) == 2:
-            img = np.expand_dims(img, 2)
-
-        if img.shape[2] == 1:
-            img = np.repeat(img, 3, axis=2)
-        elif (img.shape[2] > 3):
-            img_classes = img.argmax(2)
-            img = color.label2rgb(img_classes, colors=COLORS)
-
-        if mask_only_first:
-            need_mark_boundaries = i == 0
-        else:
-            need_mark_boundaries = i < len(keys) - 1 or not last_without_mask
-
-        if need_mark_boundaries:
-            if black_mask:
-                img = img * (1 - mask[0][..., None])
-            img = mark_boundaries(img,
-                                  mask[0],
-                                  color=(1., 0., 0.),
-                                  outline_color=(1., 1., 1.),
-                                  mode='thick')
-        result.append(img)
-    return np.concatenate(result, axis=1)
-
-
-def visualize_mask_and_images_batch(batch: Dict[str, torch.Tensor], keys: List[str], max_items=10,
-                                    last_without_mask=True, rescale_keys=None) -> np.ndarray:
-    batch = {k: tens.detach().cpu().numpy() for k, tens in batch.items()
-             if k in keys or k == 'mask'}
-
-    batch_size = next(iter(batch.values())).shape[0]
-    items_to_vis = min(batch_size, max_items)
-    result = []
-    for i in range(items_to_vis):
-        cur_dct = {k: tens[i] for k, tens in batch.items()}
-        result.append(visualize_mask_and_images(cur_dct, keys, last_without_mask=last_without_mask,
-                                                rescale_keys=rescale_keys))
-    return np.concatenate(result, axis=0)
diff --git a/spaces/ali-ghamdan/realesrgan-models/docs/feedback.md b/spaces/ali-ghamdan/realesrgan-models/docs/feedback.md
deleted file mode 100644
index c621ed05e9bc122a2ae6309eac61583ab9f35e7a..0000000000000000000000000000000000000000
--- a/spaces/ali-ghamdan/realesrgan-models/docs/feedback.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# Feedback 反馈
-
-## 动漫插画模型
-
-1. 视频处理不了: 目前的模型，不是针对视频的，所以视频效果很很不好。我们在探究针对视频的模型了
-1. 景深虚化有问题: 现在的模型把一些景深 和 特意的虚化 都复原了，感觉不好。这个后面我们会考虑把这个信息结合进入。一个简单的做法是识别景深和虚化，然后作为条件告诉神经网络，哪些地方复原强一些，哪些地方复原要弱一些
-1. 不可以调节: 像 Waifu2X 可以调节。可以根据自己的喜好，做调整，但是 Real-ESRGAN-anime 并不可以。导致有些恢复效果过了
-1. 把原来的风格改变了: 不同的动漫插画都有自己的风格，现在的 Real-ESRGAN-anime 倾向于恢复成一种风格（这是受到训练数据集影响的）。风格是动漫很重要的一个要素，所以要尽可能保持
-1. 模型太大: 目前的模型处理太慢，能够更快。这个我们有相关的工作在探究，希望能够尽快有结果，并应用到 Real-ESRGAN 这一系列的模型上
-
-Thanks for the [detailed and valuable feedbacks/suggestions](https://github.com/xinntao/Real-ESRGAN/issues/131) by [2ji3150](https://github.com/2ji3150).
diff --git a/spaces/allknowingroger/Image-Models-Test66/README.md b/spaces/allknowingroger/Image-Models-Test66/README.md
deleted file mode 100644
index 65ad1852d6681ad9299030157281b12d6ab847d3..0000000000000000000000000000000000000000
--- a/spaces/allknowingroger/Image-Models-Test66/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Image Models
-emoji: 👀
-colorFrom: red
-colorTo: gray
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: true
-duplicated_from: allknowingroger/Image-Models-Test65
----
-
-<!--Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference-->
\ No newline at end of file
diff --git a/spaces/alperbayram/Duygu_Analizi/app.py b/spaces/alperbayram/Duygu_Analizi/app.py
deleted file mode 100644
index 77a45e23584378e90aa5f6c1869762de99c73a92..0000000000000000000000000000000000000000
--- a/spaces/alperbayram/Duygu_Analizi/app.py
+++ /dev/null
@@ -1,12 +0,0 @@
-import gradio as gr
-from transformers import AutoModelForSequenceClassification, AutoTokenizer, pipeline
-
-model = AutoModelForSequenceClassification.from_pretrained("savasy/bert-base-turkish-sentiment-cased")
-tokenizer = AutoTokenizer.from_pretrained("savasy/bert-base-turkish-sentiment-cased")
-
-def greet(text):
-    pipe = pipeline("sentiment-analysis", tokenizer=tokenizer, model=model)
-    return pipe(text)[0]['label']
-    
-iface = gr.Interface(fn=greet, inputs=gr.inputs.Textbox(placeholder="Lütfen Cümle Giriniz...", lines=5), outputs="text")
-iface.launch()
\ No newline at end of file
diff --git a/spaces/anaclaudia13ct/insect_detection/utils/loggers/comet/README.md b/spaces/anaclaudia13ct/insect_detection/utils/loggers/comet/README.md
deleted file mode 100644
index 8f206cd9830e0a7c88e8a303390eebaa7aaae1df..0000000000000000000000000000000000000000
--- a/spaces/anaclaudia13ct/insect_detection/utils/loggers/comet/README.md
+++ /dev/null
@@ -1,256 +0,0 @@
-<img src="https://cdn.comet.ml/img/notebook_logo.png">
-
-# YOLOv5 with Comet
-
-This guide will cover how to use YOLOv5 with [Comet](https://bit.ly/yolov5-readme-comet)
-
-# About Comet
-
-Comet builds tools that help data scientists, engineers, and team leaders accelerate and optimize machine learning and deep learning models.
-
-Track and visualize model metrics in real time, save your hyperparameters, datasets, and model checkpoints, and visualize your model predictions with [Comet Custom Panels](https://bit.ly/yolov5-colab-comet-panels)!
-Comet makes sure you never lose track of your work and makes it easy to share results and collaborate across teams of all sizes!
-
-# Getting Started
-
-## Install Comet
-
-```shell
-pip install comet_ml
-```
-
-## Configure Comet Credentials
-
-There are two ways to configure Comet with YOLOv5.
-
-You can either set your credentials through enviroment variables
-
-**Environment Variables**
-
-```shell
-export COMET_API_KEY=<Your Comet API Key>
-export COMET_PROJECT_NAME=<Your Comet Project Name> # This will default to 'yolov5'
-```
-
-Or create a `.comet.config` file in your working directory and set your credentials there.
-
-**Comet Configuration File**
-
-```
-[comet]
-api_key=<Your Comet API Key>
-project_name=<Your Comet Project Name> # This will default to 'yolov5'
-```
-
-## Run the Training Script
-
-```shell
-# Train YOLOv5s on COCO128 for 5 epochs
-python train.py --img 640 --batch 16 --epochs 5 --data coco128.yaml --weights yolov5s.pt
-```
-
-That's it! Comet will automatically log your hyperparameters, command line arguments, training and valiation metrics. You can visualize and analyze your runs in the Comet UI
-
-<img width="1920" alt="yolo-ui" src="https://user-images.githubusercontent.com/26833433/202851203-164e94e1-2238-46dd-91f8-de020e9d6b41.png">
-
-# Try out an Example!
-Check out an example of a [completed run here](https://www.comet.com/examples/comet-example-yolov5/a0e29e0e9b984e4a822db2a62d0cb357?experiment-tab=chart&showOutliers=true&smoothing=0&transformY=smoothing&xAxis=step&ref=yolov5&utm_source=yolov5&utm_medium=affilliate&utm_campaign=yolov5_comet_integration)
-
-Or better yet, try it out yourself in this Colab Notebook
-
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1RG0WOQyxlDlo5Km8GogJpIEJlg_5lyYO?usp=sharing)
-
-# Log automatically
-
-By default, Comet will log the following items
-
-## Metrics
-- Box Loss, Object Loss, Classification Loss for the training and validation data
-- mAP_0.5, mAP_0.5:0.95 metrics for the validation data.
-- Precision and Recall for the validation data
-
-## Parameters
-
-- Model Hyperparameters
-- All parameters passed through the command line options
-
-## Visualizations
-
-- Confusion Matrix of the model predictions on the validation data
-- Plots for the PR and F1 curves across all classes
-- Correlogram of the Class Labels
-
-# Configure Comet Logging
-
-Comet can be configured to log additional data either through command line flags passed to the training script
-or through environment variables.
-
-```shell
-export COMET_MODE=online # Set whether to run Comet in 'online' or 'offline' mode. Defaults to online
-export COMET_MODEL_NAME=<your model name> #Set the name for the saved model. Defaults to yolov5
-export COMET_LOG_CONFUSION_MATRIX=false # Set to disable logging a Comet Confusion Matrix. Defaults to true
-export COMET_MAX_IMAGE_UPLOADS=<number of allowed images to upload to Comet> # Controls how many total image predictions to log to Comet. Defaults to 100.
-export COMET_LOG_PER_CLASS_METRICS=true # Set to log evaluation metrics for each detected class at the end of training. Defaults to false
-export COMET_DEFAULT_CHECKPOINT_FILENAME=<your checkpoint filename> # Set this if you would like to resume training from a different checkpoint. Defaults to 'last.pt'
-export COMET_LOG_BATCH_LEVEL_METRICS=true # Set this if you would like to log training metrics at the batch level. Defaults to false.
-export COMET_LOG_PREDICTIONS=true # Set this to false to disable logging model predictions
-```
-
-## Logging Checkpoints with Comet
-
-Logging Models to Comet is disabled by default. To enable it, pass the `save-period` argument to the training script. This will save the
-logged checkpoints to Comet based on the interval value provided by `save-period`
-
-```shell
-python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data coco128.yaml \
---weights yolov5s.pt \
---save-period 1
-```
-
-## Logging Model Predictions
-
-By default, model predictions (images, ground truth labels and bounding boxes) will be logged to Comet.
-
-You can control the frequency of logged predictions and the associated images by passing the `bbox_interval` command line argument. Predictions can be visualized using Comet's Object Detection Custom Panel. This frequency corresponds to every Nth batch of data per epoch. In the example below, we are logging every 2nd batch of data for each epoch.
-
-**Note:** The YOLOv5 validation dataloader will default to a batch size of 32, so you will have to set the logging frequency accordingly.
-
-Here is an [example project using the Panel](https://www.comet.com/examples/comet-example-yolov5?shareable=YcwMiJaZSXfcEXpGOHDD12vA1&ref=yolov5&utm_source=yolov5&utm_medium=affilliate&utm_campaign=yolov5_comet_integration)
-
-
-```shell
-python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data coco128.yaml \
---weights yolov5s.pt \
---bbox_interval 2
-```
-
-### Controlling the number of Prediction Images logged to Comet
-
-When logging predictions from YOLOv5, Comet will log the images associated with each set of predictions. By default a maximum of 100 validation images are logged. You can increase or decrease this number using the `COMET_MAX_IMAGE_UPLOADS` environment variable.
-
-```shell
-env COMET_MAX_IMAGE_UPLOADS=200 python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data coco128.yaml \
---weights yolov5s.pt \
---bbox_interval 1
-```
-
-### Logging Class Level Metrics
-
-Use the `COMET_LOG_PER_CLASS_METRICS` environment variable to log mAP, precision, recall, f1 for each class.
-
-```shell
-env COMET_LOG_PER_CLASS_METRICS=true python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data coco128.yaml \
---weights yolov5s.pt
-```
-
-## Uploading a Dataset to Comet Artifacts
-
-If you would like to store your data using [Comet Artifacts](https://www.comet.com/docs/v2/guides/data-management/using-artifacts/#learn-more?ref=yolov5&utm_source=yolov5&utm_medium=affilliate&utm_campaign=yolov5_comet_integration), you can do so using the `upload_dataset` flag.
-
-The dataset be organized in the way described in the [YOLOv5 documentation](https://docs.ultralytics.com/tutorials/train-custom-datasets/#3-organize-directories). The dataset config `yaml` file must follow the same format as that of the `coco128.yaml` file.
-
-```shell
-python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data coco128.yaml \
---weights yolov5s.pt \
---upload_dataset
-```
-
-You can find the uploaded dataset in the Artifacts tab in your Comet Workspace
-<img width="1073" alt="artifact-1" src="https://user-images.githubusercontent.com/7529846/186929193-162718bf-ec7b-4eb9-8c3b-86b3763ef8ea.png">
-
-You can preview the data directly in the Comet UI.
-<img width="1082" alt="artifact-2" src="https://user-images.githubusercontent.com/7529846/186929215-432c36a9-c109-4eb0-944b-84c2786590d6.png">
-
-Artifacts are versioned and also support adding metadata about the dataset. Comet will automatically log the metadata from your dataset `yaml` file
-<img width="963" alt="artifact-3" src="https://user-images.githubusercontent.com/7529846/186929256-9d44d6eb-1a19-42de-889a-bcbca3018f2e.png">
-
-### Using a saved Artifact
-
-If you would like to use a dataset from Comet Artifacts, set the `path` variable in your dataset `yaml` file to point to the following Artifact resource URL.
-
-```
-# contents of artifact.yaml file
-path: "comet://<workspace name>/<artifact name>:<artifact version or alias>"
-```
-Then pass this file to your training script in the following way
-
-```shell
-python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data artifact.yaml \
---weights yolov5s.pt
-```
-
-Artifacts also allow you to track the lineage of data as it flows through your Experimentation workflow. Here you can see a graph that shows you all the experiments that have used your uploaded dataset.
-<img width="1391" alt="artifact-4" src="https://user-images.githubusercontent.com/7529846/186929264-4c4014fa-fe51-4f3c-a5c5-f6d24649b1b4.png">
-
-## Resuming a Training Run
-
-If your training run is interrupted for any reason, e.g. disrupted internet connection, you can resume the run using the `resume` flag and the Comet Run Path.
-
-The Run Path has the following format `comet://<your workspace name>/<your project name>/<experiment id>`.
-
-This will restore the run to its state before the interruption, which includes restoring the  model from a checkpoint, restoring all hyperparameters and training arguments and downloading Comet dataset Artifacts if they were used in the original run. The resumed run will continue logging to the existing Experiment in the Comet UI
-
-```shell
-python train.py \
---resume "comet://<your run path>"
-```
-
-## Hyperparameter Search with the Comet Optimizer
-
-YOLOv5 is also integrated with Comet's Optimizer, making is simple to visualie hyperparameter sweeps in the Comet UI.
-
-### Configuring an Optimizer Sweep
-
-To configure the Comet Optimizer, you will have to create a JSON file with the information about the sweep. An example file has been provided in `utils/loggers/comet/optimizer_config.json`
-
-```shell
-python utils/loggers/comet/hpo.py \
-  --comet_optimizer_config "utils/loggers/comet/optimizer_config.json"
-```
-
-The `hpo.py` script accepts the same arguments as `train.py`. If you wish to pass additional arguments to your sweep simply add them after
-the script.
-
-```shell
-python utils/loggers/comet/hpo.py \
-  --comet_optimizer_config "utils/loggers/comet/optimizer_config.json" \
-  --save-period 1 \
-  --bbox_interval 1
-```
-
-### Running a Sweep in Parallel
-
-```shell
-comet optimizer -j <set number of workers> utils/loggers/comet/hpo.py \
-  utils/loggers/comet/optimizer_config.json"
-```
-
-### Visualizing Results
-
-Comet provides a number of ways to visualize the results of your sweep. Take a look at a [project with a completed sweep here](https://www.comet.com/examples/comet-example-yolov5/view/PrlArHGuuhDTKC1UuBmTtOSXD/panels?ref=yolov5&utm_source=yolov5&utm_medium=affilliate&utm_campaign=yolov5_comet_integration)
-
-<img width="1626" alt="hyperparameter-yolo" src="https://user-images.githubusercontent.com/7529846/186914869-7dc1de14-583f-4323-967b-c9a66a29e495.png">
diff --git a/spaces/ankitinter9/my-draw-self-journey/style.css b/spaces/ankitinter9/my-draw-self-journey/style.css
deleted file mode 100644
index 17fb109b7cef35a21bc44dcefba0ea3c2913f0ee..0000000000000000000000000000000000000000
--- a/spaces/ankitinter9/my-draw-self-journey/style.css
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
-This CSS file is modified from:
-https://huggingface.co/spaces/stabilityai/stable-diffusion/blob/2794a3c3ba66115c307075098e713f572b08bf80/app.py
-*/
-
-h1 {
-  text-align: center;
-}
-
-.gradio-container {
-  font-family: 'IBM Plex Sans', sans-serif;
-}
-
-.gr-button {
-  color: white;
-  border-color: black;
-  background: black;
-}
-
-input[type='range'] {
-  accent-color: black;
-}
-
-.dark input[type='range'] {
-  accent-color: #dfdfdf;
-}
-
-.container {
-  max-width: 730px;
-  margin: auto;
-  padding-top: 1.5rem;
-}
-
-#gallery {
-  min-height: auto;
-  height: 185px;
-  margin-top: 15px;
-  margin-left: auto;
-  margin-right: auto;
-  border-bottom-right-radius: .5rem !important;
-  border-bottom-left-radius: .5rem !important;
-}
-#gallery .grid-wrap, #gallery .empty{
-  height: 185px;
-  min-height: 185px;
-}
-#gallery .preview{
-  height: 185px;
-  min-height: 185px!important;
-}
-#gallery>div>.h-full {
-  min-height: 20rem;
-}
-
-.details:hover {
-  text-decoration: underline;
-}
-
-.gr-button {
-  white-space: nowrap;
-}
-
-.gr-button:focus {
-  border-color: rgb(147 197 253 / var(--tw-border-opacity));
-  outline: none;
-  box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000);
-  --tw-border-opacity: 1;
-  --tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
-  --tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(3px var(--tw-ring-offset-width)) var(--tw-ring-color);
-  --tw-ring-color: rgb(191 219 254 / var(--tw-ring-opacity));
-  --tw-ring-opacity: .5;
-}
-
-#advanced-btn {
-  font-size: .7rem !important;
-  line-height: 19px;
-  margin-top: 12px;
-  margin-bottom: 12px;
-  padding: 2px 8px;
-  border-radius: 14px !important;
-}
-
-#advanced-options {
-  display: none;
-  margin-bottom: 20px;
-}
-
-.footer {
-  margin-bottom: 45px;
-  margin-top: 35px;
-  text-align: center;
-  border-bottom: 1px solid #e5e5e5;
-}
-
-.footer>p {
-  font-size: .8rem;
-  display: inline-block;
-  padding: 0 10px;
-  transform: translateY(10px);
-  background: white;
-}
-
-.dark .footer {
-  border-color: #303030;
-}
-
-.dark .footer>p {
-  background: #0b0f19;
-}
-
-.acknowledgments h4 {
-  margin: 1.25em 0 .25em 0;
-  font-weight: bold;
-  font-size: 115%;
-}
-
-.animate-spin {
-  animation: spin 1s linear infinite;
-}
-
-@keyframes spin {
-  from {
-    transform: rotate(0deg);
-  }
-
-  to {
-    transform: rotate(360deg);
-  }
-}
-
-#share-btn-container {
-  display: flex;
-  padding-left: 0.5rem !important;
-  padding-right: 0.5rem !important;
-  background-color: #000000;
-  justify-content: center;
-  align-items: center;
-  border-radius: 9999px !important;
-  width: 13rem;
-  margin-top: 10px;
-  margin-left: auto;
-}
-
-#share-btn {
-  all: initial;
-  color: #ffffff;
-  font-weight: 600;
-  cursor: pointer;
-  font-family: 'IBM Plex Sans', sans-serif;
-  margin-left: 0.5rem !important;
-  padding-top: 0.25rem !important;
-  padding-bottom: 0.25rem !important;
-  right: 0;
-}
-
-#share-btn * {
-  all: unset;
-}
-
-#share-btn-container div:nth-child(-n+2) {
-  width: auto !important;
-  min-height: 0px !important;
-}
-
-#share-btn-container .wrap {
-  display: none !important;
-}
-
-.gr-form {
-  flex: 1 1 50%;
-  border-top-right-radius: 0;
-  border-bottom-right-radius: 0;
-}
-
-#prompt-container {
-  gap: 0;
-}
-
-#prompt-text-input,
-#negative-prompt-text-input {
-  padding: .45rem 0.625rem
-}
-
-#component-16 {
-  border-top-width: 1px !important;
-  margin-top: 1em
-}
-
-.image_duplication {
-  position: absolute;
-  width: 100px;
-  left: 50px
-}
-
-#component-0 {
-  max-width: 730px;
-  margin: auto;
-  padding-top: 1.5rem;
-}
-
-#upscaled-image img {
-  object-fit: scale-down;
-}
-/* share button */
-#share-btn-container {
-  display: flex;
-  padding-left: 0.5rem !important;
-  padding-right: 0.5rem !important;
-  background-color: #000000;
-  justify-content: center;
-  align-items: center;
-  border-radius: 9999px !important; 
-  width: 13rem;
-  margin-top: 10px;
-  margin-left: auto;
-  flex: unset !important;
-}
-#share-btn {
-  all: initial;
-  color: #ffffff;
-  font-weight: 600;
-  cursor: pointer;
-  font-family: 'IBM Plex Sans', sans-serif;
-  margin-left: 0.5rem !important;
-  padding-top: 0.25rem !important;
-  padding-bottom: 0.25rem !important;
-  right:0;
-}
-#share-btn * {
-  all: unset !important;
-}
-#share-btn-container div:nth-child(-n+2){
-  width: auto !important;
-  min-height: 0px !important;
-}
-#share-btn-container .wrap {
-  display: none !important;
-}
\ No newline at end of file
diff --git a/spaces/aodianyun/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/src/rife/model/loss.py b/spaces/aodianyun/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/src/rife/model/loss.py
deleted file mode 100644
index 72e5de6af050df7d55c2871a69637077970ddfb9..0000000000000000000000000000000000000000
--- a/spaces/aodianyun/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/src/rife/model/loss.py
+++ /dev/null
@@ -1,128 +0,0 @@
-import torch
-import numpy as np
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision.models as models
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-
-class EPE(nn.Module):
-    def __init__(self):
-        super(EPE, self).__init__()
-
-    def forward(self, flow, gt, loss_mask):
-        loss_map = (flow - gt.detach()) ** 2
-        loss_map = (loss_map.sum(1, True) + 1e-6) ** 0.5
-        return (loss_map * loss_mask)
-
-
-class Ternary(nn.Module):
-    def __init__(self):
-        super(Ternary, self).__init__()
-        patch_size = 7
-        out_channels = patch_size * patch_size
-        self.w = np.eye(out_channels).reshape(
-            (patch_size, patch_size, 1, out_channels))
-        self.w = np.transpose(self.w, (3, 2, 0, 1))
-        self.w = torch.tensor(self.w).float().to(device)
-
-    def transform(self, img):
-        patches = F.conv2d(img, self.w, padding=3, bias=None)
-        transf = patches - img
-        transf_norm = transf / torch.sqrt(0.81 + transf**2)
-        return transf_norm
-
-    def rgb2gray(self, rgb):
-        r, g, b = rgb[:, 0:1, :, :], rgb[:, 1:2, :, :], rgb[:, 2:3, :, :]
-        gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
-        return gray
-
-    def hamming(self, t1, t2):
-        dist = (t1 - t2) ** 2
-        dist_norm = torch.mean(dist / (0.1 + dist), 1, True)
-        return dist_norm
-
-    def valid_mask(self, t, padding):
-        n, _, h, w = t.size()
-        inner = torch.ones(n, 1, h - 2 * padding, w - 2 * padding).type_as(t)
-        mask = F.pad(inner, [padding] * 4)
-        return mask
-
-    def forward(self, img0, img1):
-        img0 = self.transform(self.rgb2gray(img0))
-        img1 = self.transform(self.rgb2gray(img1))
-        return self.hamming(img0, img1) * self.valid_mask(img0, 1)
-
-
-class SOBEL(nn.Module):
-    def __init__(self):
-        super(SOBEL, self).__init__()
-        self.kernelX = torch.tensor([
-            [1, 0, -1],
-            [2, 0, -2],
-            [1, 0, -1],
-        ]).float()
-        self.kernelY = self.kernelX.clone().T
-        self.kernelX = self.kernelX.unsqueeze(0).unsqueeze(0).to(device)
-        self.kernelY = self.kernelY.unsqueeze(0).unsqueeze(0).to(device)
-
-    def forward(self, pred, gt):
-        N, C, H, W = pred.shape[0], pred.shape[1], pred.shape[2], pred.shape[3]
-        img_stack = torch.cat(
-            [pred.reshape(N*C, 1, H, W), gt.reshape(N*C, 1, H, W)], 0)
-        sobel_stack_x = F.conv2d(img_stack, self.kernelX, padding=1)
-        sobel_stack_y = F.conv2d(img_stack, self.kernelY, padding=1)
-        pred_X, gt_X = sobel_stack_x[:N*C], sobel_stack_x[N*C:]
-        pred_Y, gt_Y = sobel_stack_y[:N*C], sobel_stack_y[N*C:]
-
-        L1X, L1Y = torch.abs(pred_X-gt_X), torch.abs(pred_Y-gt_Y)
-        loss = (L1X+L1Y)
-        return loss
-
-class MeanShift(nn.Conv2d):
-    def __init__(self, data_mean, data_std, data_range=1, norm=True):
-        c = len(data_mean)
-        super(MeanShift, self).__init__(c, c, kernel_size=1)
-        std = torch.Tensor(data_std)
-        self.weight.data = torch.eye(c).view(c, c, 1, 1)
-        if norm:
-            self.weight.data.div_(std.view(c, 1, 1, 1))
-            self.bias.data = -1 * data_range * torch.Tensor(data_mean)
-            self.bias.data.div_(std)
-        else:
-            self.weight.data.mul_(std.view(c, 1, 1, 1))
-            self.bias.data = data_range * torch.Tensor(data_mean)
-        self.requires_grad = False
-            
-class VGGPerceptualLoss(torch.nn.Module):
-    def __init__(self, rank=0):
-        super(VGGPerceptualLoss, self).__init__()
-        blocks = []
-        pretrained = True
-        self.vgg_pretrained_features = models.vgg19(pretrained=pretrained).features
-        self.normalize = MeanShift([0.485, 0.456, 0.406], [0.229, 0.224, 0.225], norm=True).cuda()
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, X, Y, indices=None):
-        X = self.normalize(X)
-        Y = self.normalize(Y)
-        indices = [2, 7, 12, 21, 30]
-        weights = [1.0/2.6, 1.0/4.8, 1.0/3.7, 1.0/5.6, 10/1.5]
-        k = 0
-        loss = 0
-        for i in range(indices[-1]):
-            X = self.vgg_pretrained_features[i](X)
-            Y = self.vgg_pretrained_features[i](Y)
-            if (i+1) in indices:
-                loss += weights[k] * (X - Y.detach()).abs().mean() * 0.1
-                k += 1
-        return loss
-
-if __name__ == '__main__':
-    img0 = torch.zeros(3, 3, 256, 256).float().to(device)
-    img1 = torch.tensor(np.random.normal(
-        0, 1, (3, 3, 256, 256))).float().to(device)
-    ternary_loss = Ternary()
-    print(ternary_loss(img0, img1).shape)
diff --git a/spaces/arampacha/chat-with-simpsons/README.md b/spaces/arampacha/chat-with-simpsons/README.md
deleted file mode 100644
index ae06b274e53b7e1176ad441474824bcaf47b0b2c..0000000000000000000000000000000000000000
--- a/spaces/arampacha/chat-with-simpsons/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Chat With Simpsons
-emoji: 🍩
-colorFrom: green
-colorTo: gray
-sdk: streamlit
-app_file: app.py
-pinned: false
----
-
-# Configuration
-
-`title`: _string_  
-Display title for the Space
-
-`emoji`: _string_  
-Space emoji (emoji-only character allowed)
-
-`colorFrom`: _string_  
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`colorTo`: _string_  
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`sdk`: _string_  
-Can be either `gradio` or `streamlit`
-
-`app_file`: _string_  
-Path to your main application file (which contains either `gradio` or `streamlit` Python code).  
-Path is relative to the root of the repository.
-
-`pinned`: _boolean_  
-Whether the Space stays on top of your list.
diff --git a/spaces/artificialguybr/video-dubbing/TTS/TTS/bin/extract_tts_spectrograms.py b/spaces/artificialguybr/video-dubbing/TTS/TTS/bin/extract_tts_spectrograms.py
deleted file mode 100644
index 9eadee070ed15283e4460331cbb48927392a2b12..0000000000000000000000000000000000000000
--- a/spaces/artificialguybr/video-dubbing/TTS/TTS/bin/extract_tts_spectrograms.py
+++ /dev/null
@@ -1,286 +0,0 @@
-#!/usr/bin/env python3
-"""Extract Mel spectrograms with teacher forcing."""
-
-import argparse
-import os
-
-import numpy as np
-import torch
-from torch.utils.data import DataLoader
-from tqdm import tqdm
-
-from TTS.config import load_config
-from TTS.tts.datasets import TTSDataset, load_tts_samples
-from TTS.tts.models import setup_model
-from TTS.tts.utils.speakers import SpeakerManager
-from TTS.tts.utils.text.tokenizer import TTSTokenizer
-from TTS.utils.audio import AudioProcessor
-from TTS.utils.generic_utils import count_parameters
-
-use_cuda = torch.cuda.is_available()
-
-
-def setup_loader(ap, r, verbose=False):
-    tokenizer, _ = TTSTokenizer.init_from_config(c)
-    dataset = TTSDataset(
-        outputs_per_step=r,
-        compute_linear_spec=False,
-        samples=meta_data,
-        tokenizer=tokenizer,
-        ap=ap,
-        batch_group_size=0,
-        min_text_len=c.min_text_len,
-        max_text_len=c.max_text_len,
-        min_audio_len=c.min_audio_len,
-        max_audio_len=c.max_audio_len,
-        phoneme_cache_path=c.phoneme_cache_path,
-        precompute_num_workers=0,
-        use_noise_augment=False,
-        verbose=verbose,
-        speaker_id_mapping=speaker_manager.name_to_id if c.use_speaker_embedding else None,
-        d_vector_mapping=speaker_manager.embeddings if c.use_d_vector_file else None,
-    )
-
-    if c.use_phonemes and c.compute_input_seq_cache:
-        # precompute phonemes to have a better estimate of sequence lengths.
-        dataset.compute_input_seq(c.num_loader_workers)
-    dataset.preprocess_samples()
-
-    loader = DataLoader(
-        dataset,
-        batch_size=c.batch_size,
-        shuffle=False,
-        collate_fn=dataset.collate_fn,
-        drop_last=False,
-        sampler=None,
-        num_workers=c.num_loader_workers,
-        pin_memory=False,
-    )
-    return loader
-
-
-def set_filename(wav_path, out_path):
-    wav_file = os.path.basename(wav_path)
-    file_name = wav_file.split(".")[0]
-    os.makedirs(os.path.join(out_path, "quant"), exist_ok=True)
-    os.makedirs(os.path.join(out_path, "mel"), exist_ok=True)
-    os.makedirs(os.path.join(out_path, "wav_gl"), exist_ok=True)
-    os.makedirs(os.path.join(out_path, "wav"), exist_ok=True)
-    wavq_path = os.path.join(out_path, "quant", file_name)
-    mel_path = os.path.join(out_path, "mel", file_name)
-    wav_gl_path = os.path.join(out_path, "wav_gl", file_name + ".wav")
-    wav_path = os.path.join(out_path, "wav", file_name + ".wav")
-    return file_name, wavq_path, mel_path, wav_gl_path, wav_path
-
-
-def format_data(data):
-    # setup input data
-    text_input = data["token_id"]
-    text_lengths = data["token_id_lengths"]
-    mel_input = data["mel"]
-    mel_lengths = data["mel_lengths"]
-    item_idx = data["item_idxs"]
-    d_vectors = data["d_vectors"]
-    speaker_ids = data["speaker_ids"]
-    attn_mask = data["attns"]
-    avg_text_length = torch.mean(text_lengths.float())
-    avg_spec_length = torch.mean(mel_lengths.float())
-
-    # dispatch data to GPU
-    if use_cuda:
-        text_input = text_input.cuda(non_blocking=True)
-        text_lengths = text_lengths.cuda(non_blocking=True)
-        mel_input = mel_input.cuda(non_blocking=True)
-        mel_lengths = mel_lengths.cuda(non_blocking=True)
-        if speaker_ids is not None:
-            speaker_ids = speaker_ids.cuda(non_blocking=True)
-        if d_vectors is not None:
-            d_vectors = d_vectors.cuda(non_blocking=True)
-        if attn_mask is not None:
-            attn_mask = attn_mask.cuda(non_blocking=True)
-    return (
-        text_input,
-        text_lengths,
-        mel_input,
-        mel_lengths,
-        speaker_ids,
-        d_vectors,
-        avg_text_length,
-        avg_spec_length,
-        attn_mask,
-        item_idx,
-    )
-
-
-@torch.no_grad()
-def inference(
-    model_name,
-    model,
-    ap,
-    text_input,
-    text_lengths,
-    mel_input,
-    mel_lengths,
-    speaker_ids=None,
-    d_vectors=None,
-):
-    if model_name == "glow_tts":
-        speaker_c = None
-        if speaker_ids is not None:
-            speaker_c = speaker_ids
-        elif d_vectors is not None:
-            speaker_c = d_vectors
-        outputs = model.inference_with_MAS(
-            text_input,
-            text_lengths,
-            mel_input,
-            mel_lengths,
-            aux_input={"d_vectors": speaker_c, "speaker_ids": speaker_ids},
-        )
-        model_output = outputs["model_outputs"]
-        model_output = model_output.detach().cpu().numpy()
-
-    elif "tacotron" in model_name:
-        aux_input = {"speaker_ids": speaker_ids, "d_vectors": d_vectors}
-        outputs = model(text_input, text_lengths, mel_input, mel_lengths, aux_input)
-        postnet_outputs = outputs["model_outputs"]
-        # normalize tacotron output
-        if model_name == "tacotron":
-            mel_specs = []
-            postnet_outputs = postnet_outputs.data.cpu().numpy()
-            for b in range(postnet_outputs.shape[0]):
-                postnet_output = postnet_outputs[b]
-                mel_specs.append(torch.FloatTensor(ap.out_linear_to_mel(postnet_output.T).T))
-            model_output = torch.stack(mel_specs).cpu().numpy()
-
-        elif model_name == "tacotron2":
-            model_output = postnet_outputs.detach().cpu().numpy()
-    return model_output
-
-
-def extract_spectrograms(
-    data_loader, model, ap, output_path, quantized_wav=False, save_audio=False, debug=False, metada_name="metada.txt"
-):
-    model.eval()
-    export_metadata = []
-    for _, data in tqdm(enumerate(data_loader), total=len(data_loader)):
-        # format data
-        (
-            text_input,
-            text_lengths,
-            mel_input,
-            mel_lengths,
-            speaker_ids,
-            d_vectors,
-            _,
-            _,
-            _,
-            item_idx,
-        ) = format_data(data)
-
-        model_output = inference(
-            c.model.lower(),
-            model,
-            ap,
-            text_input,
-            text_lengths,
-            mel_input,
-            mel_lengths,
-            speaker_ids,
-            d_vectors,
-        )
-
-        for idx in range(text_input.shape[0]):
-            wav_file_path = item_idx[idx]
-            wav = ap.load_wav(wav_file_path)
-            _, wavq_path, mel_path, wav_gl_path, wav_path = set_filename(wav_file_path, output_path)
-
-            # quantize and save wav
-            if quantized_wav:
-                wavq = ap.quantize(wav)
-                np.save(wavq_path, wavq)
-
-            # save TTS mel
-            mel = model_output[idx]
-            mel_length = mel_lengths[idx]
-            mel = mel[:mel_length, :].T
-            np.save(mel_path, mel)
-
-            export_metadata.append([wav_file_path, mel_path])
-            if save_audio:
-                ap.save_wav(wav, wav_path)
-
-            if debug:
-                print("Audio for debug saved at:", wav_gl_path)
-                wav = ap.inv_melspectrogram(mel)
-                ap.save_wav(wav, wav_gl_path)
-
-    with open(os.path.join(output_path, metada_name), "w", encoding="utf-8") as f:
-        for data in export_metadata:
-            f.write(f"{data[0]}|{data[1]+'.npy'}\n")
-
-
-def main(args):  # pylint: disable=redefined-outer-name
-    # pylint: disable=global-variable-undefined
-    global meta_data, speaker_manager
-
-    # Audio processor
-    ap = AudioProcessor(**c.audio)
-
-    # load data instances
-    meta_data_train, meta_data_eval = load_tts_samples(
-        c.datasets, eval_split=args.eval, eval_split_max_size=c.eval_split_max_size, eval_split_size=c.eval_split_size
-    )
-
-    # use eval and training partitions
-    meta_data = meta_data_train + meta_data_eval
-
-    # init speaker manager
-    if c.use_speaker_embedding:
-        speaker_manager = SpeakerManager(data_items=meta_data)
-    elif c.use_d_vector_file:
-        speaker_manager = SpeakerManager(d_vectors_file_path=c.d_vector_file)
-    else:
-        speaker_manager = None
-
-    # setup model
-    model = setup_model(c)
-
-    # restore model
-    model.load_checkpoint(c, args.checkpoint_path, eval=True)
-
-    if use_cuda:
-        model.cuda()
-
-    num_params = count_parameters(model)
-    print("\n > Model has {} parameters".format(num_params), flush=True)
-    # set r
-    r = 1 if c.model.lower() == "glow_tts" else model.decoder.r
-    own_loader = setup_loader(ap, r, verbose=True)
-
-    extract_spectrograms(
-        own_loader,
-        model,
-        ap,
-        args.output_path,
-        quantized_wav=args.quantized,
-        save_audio=args.save_audio,
-        debug=args.debug,
-        metada_name="metada.txt",
-    )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--config_path", type=str, help="Path to config file for training.", required=True)
-    parser.add_argument("--checkpoint_path", type=str, help="Model file to be restored.", required=True)
-    parser.add_argument("--output_path", type=str, help="Path to save mel specs", required=True)
-    parser.add_argument("--debug", default=False, action="store_true", help="Save audio files for debug")
-    parser.add_argument("--save_audio", default=False, action="store_true", help="Save audio files")
-    parser.add_argument("--quantized", action="store_true", help="Save quantized audio files")
-    parser.add_argument("--eval", type=bool, help="compute eval.", default=True)
-    args = parser.parse_args()
-
-    c = load_config(args.config_path)
-    c.audio.trim_silence = False
-    main(args)
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Crypto/Cipher/ARC2.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Crypto/Cipher/ARC2.py
deleted file mode 100644
index 0ba7e3353421602a1c4e163fe5961b5778041a6f..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Crypto/Cipher/ARC2.py
+++ /dev/null
@@ -1,175 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#  Cipher/ARC2.py : ARC2.py
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain.  To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# 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.
-# ===================================================================
-"""
-Module's constants for the modes of operation supported with ARC2:
-
-:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
-:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
-:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
-:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
-:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
-:var MODE_OPENPGP:  :ref:`OpenPGP Mode <openpgp_mode>`
-:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
-"""
-
-import sys
-
-from Crypto.Cipher import _create_cipher
-from Crypto.Util.py3compat import byte_string
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
-                                  VoidPointer, SmartPointer,
-                                  c_size_t, c_uint8_ptr)
-
-_raw_arc2_lib = load_pycryptodome_raw_lib(
-                        "Crypto.Cipher._raw_arc2",
-                        """
-                        int ARC2_start_operation(const uint8_t key[],
-                                                 size_t key_len,
-                                                 size_t effective_key_len,
-                                                 void **pResult);
-                        int ARC2_encrypt(const void *state,
-                                         const uint8_t *in,
-                                         uint8_t *out,
-                                         size_t data_len);
-                        int ARC2_decrypt(const void *state,
-                                         const uint8_t *in,
-                                         uint8_t *out,
-                                         size_t data_len);
-                        int ARC2_stop_operation(void *state);
-                        """
-                        )
-
-
-def _create_base_cipher(dict_parameters):
-    """This method instantiates and returns a handle to a low-level
-    base cipher. It will absorb named parameters in the process."""
-
-    try:
-        key = dict_parameters.pop("key")
-    except KeyError:
-        raise TypeError("Missing 'key' parameter")
-
-    effective_keylen = dict_parameters.pop("effective_keylen", 1024)
-
-    if len(key) not in key_size:
-        raise ValueError("Incorrect ARC2 key length (%d bytes)" % len(key))
-
-    if not (40 <= effective_keylen <= 1024):
-        raise ValueError("'effective_key_len' must be at least 40 and no larger than 1024 "
-                         "(not %d)" % effective_keylen)
-
-    start_operation = _raw_arc2_lib.ARC2_start_operation
-    stop_operation = _raw_arc2_lib.ARC2_stop_operation
-
-    cipher = VoidPointer()
-    result = start_operation(c_uint8_ptr(key),
-                             c_size_t(len(key)),
-                             c_size_t(effective_keylen),
-                             cipher.address_of())
-    if result:
-        raise ValueError("Error %X while instantiating the ARC2 cipher"
-                         % result)
-
-    return SmartPointer(cipher.get(), stop_operation)
-
-
-def new(key, mode, *args, **kwargs):
-    """Create a new RC2 cipher.
-
-    :param key:
-        The secret key to use in the symmetric cipher.
-        Its length can vary from 5 to 128 bytes; the actual search space
-        (and the cipher strength) can be reduced with the ``effective_keylen`` parameter.
-    :type key: bytes, bytearray, memoryview
-
-    :param mode:
-        The chaining mode to use for encryption or decryption.
-    :type mode: One of the supported ``MODE_*`` constants
-
-    :Keyword Arguments:
-        *   **iv** (*bytes*, *bytearray*, *memoryview*) --
-            (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
-            and ``MODE_OPENPGP`` modes).
-
-            The initialization vector to use for encryption or decryption.
-
-            For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
-
-            For ``MODE_OPENPGP`` mode only,
-            it must be 8 bytes long for encryption
-            and 10 bytes for decryption (in the latter case, it is
-            actually the *encrypted* IV which was prefixed to the ciphertext).
-
-            If not provided, a random byte string is generated (you must then
-            read its value with the :attr:`iv` attribute).
-
-        *   **nonce** (*bytes*, *bytearray*, *memoryview*) --
-            (Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
-
-            A value that must never be reused for any other encryption done
-            with this key.
-
-            For ``MODE_EAX`` there are no
-            restrictions on its length (recommended: **16** bytes).
-
-            For ``MODE_CTR``, its length must be in the range **[0..7]**.
-
-            If not provided for ``MODE_EAX``, a random byte string is generated (you
-            can read it back via the ``nonce`` attribute).
-
-        *   **effective_keylen** (*integer*) --
-            Optional. Maximum strength in bits of the actual key used by the ARC2 algorithm.
-            If the supplied ``key`` parameter is longer (in bits) of the value specified
-            here, it will be weakened to match it.
-            If not specified, no limitation is applied.
-
-        *   **segment_size** (*integer*) --
-            (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
-            are segmented in. It must be a multiple of 8.
-            If not specified, it will be assumed to be 8.
-
-        *   **mac_len** : (*integer*) --
-            (Only ``MODE_EAX``)
-            Length of the authentication tag, in bytes.
-            It must be no longer than 8 (default).
-
-        *   **initial_value** : (*integer*) --
-            (Only ``MODE_CTR``). The initial value for the counter within
-            the counter block. By default it is **0**.
-
-    :Return: an ARC2 object, of the applicable mode.
-    """
-
-    return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
-
-MODE_ECB = 1
-MODE_CBC = 2
-MODE_CFB = 3
-MODE_OFB = 5
-MODE_CTR = 6
-MODE_OPENPGP = 7
-MODE_EAX = 9
-
-# Size of a data block (in bytes)
-block_size = 8
-# Size of a key (in bytes)
-key_size = range(5, 128 + 1)
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/aiohttp/connector.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/aiohttp/connector.py
deleted file mode 100644
index bf40689d81b53cd34550e9d8949767385ecd916d..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/aiohttp/connector.py
+++ /dev/null
@@ -1,1453 +0,0 @@
-import asyncio
-import functools
-import random
-import sys
-import traceback
-import warnings
-from collections import defaultdict, deque
-from contextlib import suppress
-from http.cookies import SimpleCookie
-from itertools import cycle, islice
-from time import monotonic
-from types import TracebackType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Awaitable,
-    Callable,
-    DefaultDict,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Type,
-    Union,
-    cast,
-)
-
-import attr
-
-from . import hdrs, helpers
-from .abc import AbstractResolver
-from .client_exceptions import (
-    ClientConnectionError,
-    ClientConnectorCertificateError,
-    ClientConnectorError,
-    ClientConnectorSSLError,
-    ClientHttpProxyError,
-    ClientProxyConnectionError,
-    ServerFingerprintMismatch,
-    UnixClientConnectorError,
-    cert_errors,
-    ssl_errors,
-)
-from .client_proto import ResponseHandler
-from .client_reqrep import ClientRequest, Fingerprint, _merge_ssl_params
-from .helpers import (
-    PY_36,
-    ceil_timeout,
-    get_running_loop,
-    is_ip_address,
-    noop,
-    sentinel,
-)
-from .http import RESPONSES
-from .locks import EventResultOrError
-from .resolver import DefaultResolver
-
-try:
-    import ssl
-
-    SSLContext = ssl.SSLContext
-except ImportError:  # pragma: no cover
-    ssl = None  # type: ignore[assignment]
-    SSLContext = object  # type: ignore[misc,assignment]
-
-
-__all__ = ("BaseConnector", "TCPConnector", "UnixConnector", "NamedPipeConnector")
-
-
-if TYPE_CHECKING:  # pragma: no cover
-    from .client import ClientTimeout
-    from .client_reqrep import ConnectionKey
-    from .tracing import Trace
-
-
-class _DeprecationWaiter:
-    __slots__ = ("_awaitable", "_awaited")
-
-    def __init__(self, awaitable: Awaitable[Any]) -> None:
-        self._awaitable = awaitable
-        self._awaited = False
-
-    def __await__(self) -> Any:
-        self._awaited = True
-        return self._awaitable.__await__()
-
-    def __del__(self) -> None:
-        if not self._awaited:
-            warnings.warn(
-                "Connector.close() is a coroutine, "
-                "please use await connector.close()",
-                DeprecationWarning,
-            )
-
-
-class Connection:
-
-    _source_traceback = None
-    _transport = None
-
-    def __init__(
-        self,
-        connector: "BaseConnector",
-        key: "ConnectionKey",
-        protocol: ResponseHandler,
-        loop: asyncio.AbstractEventLoop,
-    ) -> None:
-        self._key = key
-        self._connector = connector
-        self._loop = loop
-        self._protocol: Optional[ResponseHandler] = protocol
-        self._callbacks: List[Callable[[], None]] = []
-
-        if loop.get_debug():
-            self._source_traceback = traceback.extract_stack(sys._getframe(1))
-
-    def __repr__(self) -> str:
-        return f"Connection<{self._key}>"
-
-    def __del__(self, _warnings: Any = warnings) -> None:
-        if self._protocol is not None:
-            if PY_36:
-                kwargs = {"source": self}
-            else:
-                kwargs = {}
-            _warnings.warn(f"Unclosed connection {self!r}", ResourceWarning, **kwargs)
-            if self._loop.is_closed():
-                return
-
-            self._connector._release(self._key, self._protocol, should_close=True)
-
-            context = {"client_connection": self, "message": "Unclosed connection"}
-            if self._source_traceback is not None:
-                context["source_traceback"] = self._source_traceback
-            self._loop.call_exception_handler(context)
-
-    @property
-    def loop(self) -> asyncio.AbstractEventLoop:
-        warnings.warn(
-            "connector.loop property is deprecated", DeprecationWarning, stacklevel=2
-        )
-        return self._loop
-
-    @property
-    def transport(self) -> Optional[asyncio.Transport]:
-        if self._protocol is None:
-            return None
-        return self._protocol.transport
-
-    @property
-    def protocol(self) -> Optional[ResponseHandler]:
-        return self._protocol
-
-    def add_callback(self, callback: Callable[[], None]) -> None:
-        if callback is not None:
-            self._callbacks.append(callback)
-
-    def _notify_release(self) -> None:
-        callbacks, self._callbacks = self._callbacks[:], []
-
-        for cb in callbacks:
-            with suppress(Exception):
-                cb()
-
-    def close(self) -> None:
-        self._notify_release()
-
-        if self._protocol is not None:
-            self._connector._release(self._key, self._protocol, should_close=True)
-            self._protocol = None
-
-    def release(self) -> None:
-        self._notify_release()
-
-        if self._protocol is not None:
-            self._connector._release(
-                self._key, self._protocol, should_close=self._protocol.should_close
-            )
-            self._protocol = None
-
-    @property
-    def closed(self) -> bool:
-        return self._protocol is None or not self._protocol.is_connected()
-
-
-class _TransportPlaceholder:
-    """placeholder for BaseConnector.connect function"""
-
-    def close(self) -> None:
-        pass
-
-
-class BaseConnector:
-    """Base connector class.
-
-    keepalive_timeout - (optional) Keep-alive timeout.
-    force_close - Set to True to force close and do reconnect
-        after each request (and between redirects).
-    limit - The total number of simultaneous connections.
-    limit_per_host - Number of simultaneous connections to one host.
-    enable_cleanup_closed - Enables clean-up closed ssl transports.
-                            Disabled by default.
-    loop - Optional event loop.
-    """
-
-    _closed = True  # prevent AttributeError in __del__ if ctor was failed
-    _source_traceback = None
-
-    # abort transport after 2 seconds (cleanup broken connections)
-    _cleanup_closed_period = 2.0
-
-    def __init__(
-        self,
-        *,
-        keepalive_timeout: Union[object, None, float] = sentinel,
-        force_close: bool = False,
-        limit: int = 100,
-        limit_per_host: int = 0,
-        enable_cleanup_closed: bool = False,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ) -> None:
-
-        if force_close:
-            if keepalive_timeout is not None and keepalive_timeout is not sentinel:
-                raise ValueError(
-                    "keepalive_timeout cannot " "be set if force_close is True"
-                )
-        else:
-            if keepalive_timeout is sentinel:
-                keepalive_timeout = 15.0
-
-        loop = get_running_loop(loop)
-
-        self._closed = False
-        if loop.get_debug():
-            self._source_traceback = traceback.extract_stack(sys._getframe(1))
-
-        self._conns: Dict[ConnectionKey, List[Tuple[ResponseHandler, float]]] = {}
-        self._limit = limit
-        self._limit_per_host = limit_per_host
-        self._acquired: Set[ResponseHandler] = set()
-        self._acquired_per_host: DefaultDict[
-            ConnectionKey, Set[ResponseHandler]
-        ] = defaultdict(set)
-        self._keepalive_timeout = cast(float, keepalive_timeout)
-        self._force_close = force_close
-
-        # {host_key: FIFO list of waiters}
-        self._waiters = defaultdict(deque)  # type: ignore[var-annotated]
-
-        self._loop = loop
-        self._factory = functools.partial(ResponseHandler, loop=loop)
-
-        self.cookies: SimpleCookie[str] = SimpleCookie()
-
-        # start keep-alive connection cleanup task
-        self._cleanup_handle: Optional[asyncio.TimerHandle] = None
-
-        # start cleanup closed transports task
-        self._cleanup_closed_handle: Optional[asyncio.TimerHandle] = None
-        self._cleanup_closed_disabled = not enable_cleanup_closed
-        self._cleanup_closed_transports: List[Optional[asyncio.Transport]] = []
-        self._cleanup_closed()
-
-    def __del__(self, _warnings: Any = warnings) -> None:
-        if self._closed:
-            return
-        if not self._conns:
-            return
-
-        conns = [repr(c) for c in self._conns.values()]
-
-        self._close()
-
-        if PY_36:
-            kwargs = {"source": self}
-        else:
-            kwargs = {}
-        _warnings.warn(f"Unclosed connector {self!r}", ResourceWarning, **kwargs)
-        context = {
-            "connector": self,
-            "connections": conns,
-            "message": "Unclosed connector",
-        }
-        if self._source_traceback is not None:
-            context["source_traceback"] = self._source_traceback
-        self._loop.call_exception_handler(context)
-
-    def __enter__(self) -> "BaseConnector":
-        warnings.warn(
-            '"with Connector():" is deprecated, '
-            'use "async with Connector():" instead',
-            DeprecationWarning,
-        )
-        return self
-
-    def __exit__(self, *exc: Any) -> None:
-        self._close()
-
-    async def __aenter__(self) -> "BaseConnector":
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: Optional[Type[BaseException]] = None,
-        exc_value: Optional[BaseException] = None,
-        exc_traceback: Optional[TracebackType] = None,
-    ) -> None:
-        await self.close()
-
-    @property
-    def force_close(self) -> bool:
-        """Ultimately close connection on releasing if True."""
-        return self._force_close
-
-    @property
-    def limit(self) -> int:
-        """The total number for simultaneous connections.
-
-        If limit is 0 the connector has no limit.
-        The default limit size is 100.
-        """
-        return self._limit
-
-    @property
-    def limit_per_host(self) -> int:
-        """The limit for simultaneous connections to the same endpoint.
-
-        Endpoints are the same if they are have equal
-        (host, port, is_ssl) triple.
-        """
-        return self._limit_per_host
-
-    def _cleanup(self) -> None:
-        """Cleanup unused transports."""
-        if self._cleanup_handle:
-            self._cleanup_handle.cancel()
-            # _cleanup_handle should be unset, otherwise _release() will not
-            # recreate it ever!
-            self._cleanup_handle = None
-
-        now = self._loop.time()
-        timeout = self._keepalive_timeout
-
-        if self._conns:
-            connections = {}
-            deadline = now - timeout
-            for key, conns in self._conns.items():
-                alive = []
-                for proto, use_time in conns:
-                    if proto.is_connected():
-                        if use_time - deadline < 0:
-                            transport = proto.transport
-                            proto.close()
-                            if key.is_ssl and not self._cleanup_closed_disabled:
-                                self._cleanup_closed_transports.append(transport)
-                        else:
-                            alive.append((proto, use_time))
-                    else:
-                        transport = proto.transport
-                        proto.close()
-                        if key.is_ssl and not self._cleanup_closed_disabled:
-                            self._cleanup_closed_transports.append(transport)
-
-                if alive:
-                    connections[key] = alive
-
-            self._conns = connections
-
-        if self._conns:
-            self._cleanup_handle = helpers.weakref_handle(
-                self, "_cleanup", timeout, self._loop
-            )
-
-    def _drop_acquired_per_host(
-        self, key: "ConnectionKey", val: ResponseHandler
-    ) -> None:
-        acquired_per_host = self._acquired_per_host
-        if key not in acquired_per_host:
-            return
-        conns = acquired_per_host[key]
-        conns.remove(val)
-        if not conns:
-            del self._acquired_per_host[key]
-
-    def _cleanup_closed(self) -> None:
-        """Double confirmation for transport close.
-
-        Some broken ssl servers may leave socket open without proper close.
-        """
-        if self._cleanup_closed_handle:
-            self._cleanup_closed_handle.cancel()
-
-        for transport in self._cleanup_closed_transports:
-            if transport is not None:
-                transport.abort()
-
-        self._cleanup_closed_transports = []
-
-        if not self._cleanup_closed_disabled:
-            self._cleanup_closed_handle = helpers.weakref_handle(
-                self, "_cleanup_closed", self._cleanup_closed_period, self._loop
-            )
-
-    def close(self) -> Awaitable[None]:
-        """Close all opened transports."""
-        self._close()
-        return _DeprecationWaiter(noop())
-
-    def _close(self) -> None:
-        if self._closed:
-            return
-
-        self._closed = True
-
-        try:
-            if self._loop.is_closed():
-                return
-
-            # cancel cleanup task
-            if self._cleanup_handle:
-                self._cleanup_handle.cancel()
-
-            # cancel cleanup close task
-            if self._cleanup_closed_handle:
-                self._cleanup_closed_handle.cancel()
-
-            for data in self._conns.values():
-                for proto, t0 in data:
-                    proto.close()
-
-            for proto in self._acquired:
-                proto.close()
-
-            for transport in self._cleanup_closed_transports:
-                if transport is not None:
-                    transport.abort()
-
-        finally:
-            self._conns.clear()
-            self._acquired.clear()
-            self._waiters.clear()
-            self._cleanup_handle = None
-            self._cleanup_closed_transports.clear()
-            self._cleanup_closed_handle = None
-
-    @property
-    def closed(self) -> bool:
-        """Is connector closed.
-
-        A readonly property.
-        """
-        return self._closed
-
-    def _available_connections(self, key: "ConnectionKey") -> int:
-        """
-        Return number of available connections.
-
-        The limit, limit_per_host and the connection key are taken into account.
-
-        If it returns less than 1 means that there are no connections
-        available.
-        """
-        if self._limit:
-            # total calc available connections
-            available = self._limit - len(self._acquired)
-
-            # check limit per host
-            if (
-                self._limit_per_host
-                and available > 0
-                and key in self._acquired_per_host
-            ):
-                acquired = self._acquired_per_host.get(key)
-                assert acquired is not None
-                available = self._limit_per_host - len(acquired)
-
-        elif self._limit_per_host and key in self._acquired_per_host:
-            # check limit per host
-            acquired = self._acquired_per_host.get(key)
-            assert acquired is not None
-            available = self._limit_per_host - len(acquired)
-        else:
-            available = 1
-
-        return available
-
-    async def connect(
-        self, req: "ClientRequest", traces: List["Trace"], timeout: "ClientTimeout"
-    ) -> Connection:
-        """Get from pool or create new connection."""
-        key = req.connection_key
-        available = self._available_connections(key)
-
-        # Wait if there are no available connections or if there are/were
-        # waiters (i.e. don't steal connection from a waiter about to wake up)
-        if available <= 0 or key in self._waiters:
-            fut = self._loop.create_future()
-
-            # This connection will now count towards the limit.
-            self._waiters[key].append(fut)
-
-            if traces:
-                for trace in traces:
-                    await trace.send_connection_queued_start()
-
-            try:
-                await fut
-            except BaseException as e:
-                if key in self._waiters:
-                    # remove a waiter even if it was cancelled, normally it's
-                    #  removed when it's notified
-                    try:
-                        self._waiters[key].remove(fut)
-                    except ValueError:  # fut may no longer be in list
-                        pass
-
-                raise e
-            finally:
-                if key in self._waiters and not self._waiters[key]:
-                    del self._waiters[key]
-
-            if traces:
-                for trace in traces:
-                    await trace.send_connection_queued_end()
-
-        proto = self._get(key)
-        if proto is None:
-            placeholder = cast(ResponseHandler, _TransportPlaceholder())
-            self._acquired.add(placeholder)
-            self._acquired_per_host[key].add(placeholder)
-
-            if traces:
-                for trace in traces:
-                    await trace.send_connection_create_start()
-
-            try:
-                proto = await self._create_connection(req, traces, timeout)
-                if self._closed:
-                    proto.close()
-                    raise ClientConnectionError("Connector is closed.")
-            except BaseException:
-                if not self._closed:
-                    self._acquired.remove(placeholder)
-                    self._drop_acquired_per_host(key, placeholder)
-                    self._release_waiter()
-                raise
-            else:
-                if not self._closed:
-                    self._acquired.remove(placeholder)
-                    self._drop_acquired_per_host(key, placeholder)
-
-            if traces:
-                for trace in traces:
-                    await trace.send_connection_create_end()
-        else:
-            if traces:
-                # Acquire the connection to prevent race conditions with limits
-                placeholder = cast(ResponseHandler, _TransportPlaceholder())
-                self._acquired.add(placeholder)
-                self._acquired_per_host[key].add(placeholder)
-                for trace in traces:
-                    await trace.send_connection_reuseconn()
-                self._acquired.remove(placeholder)
-                self._drop_acquired_per_host(key, placeholder)
-
-        self._acquired.add(proto)
-        self._acquired_per_host[key].add(proto)
-        return Connection(self, key, proto, self._loop)
-
-    def _get(self, key: "ConnectionKey") -> Optional[ResponseHandler]:
-        try:
-            conns = self._conns[key]
-        except KeyError:
-            return None
-
-        t1 = self._loop.time()
-        while conns:
-            proto, t0 = conns.pop()
-            if proto.is_connected():
-                if t1 - t0 > self._keepalive_timeout:
-                    transport = proto.transport
-                    proto.close()
-                    # only for SSL transports
-                    if key.is_ssl and not self._cleanup_closed_disabled:
-                        self._cleanup_closed_transports.append(transport)
-                else:
-                    if not conns:
-                        # The very last connection was reclaimed: drop the key
-                        del self._conns[key]
-                    return proto
-            else:
-                transport = proto.transport
-                proto.close()
-                if key.is_ssl and not self._cleanup_closed_disabled:
-                    self._cleanup_closed_transports.append(transport)
-
-        # No more connections: drop the key
-        del self._conns[key]
-        return None
-
-    def _release_waiter(self) -> None:
-        """
-        Iterates over all waiters until one to be released is found.
-
-        The one to be released is not finsihed and
-        belongs to a host that has available connections.
-        """
-        if not self._waiters:
-            return
-
-        # Having the dict keys ordered this avoids to iterate
-        # at the same order at each call.
-        queues = list(self._waiters.keys())
-        random.shuffle(queues)
-
-        for key in queues:
-            if self._available_connections(key) < 1:
-                continue
-
-            waiters = self._waiters[key]
-            while waiters:
-                waiter = waiters.popleft()
-                if not waiter.done():
-                    waiter.set_result(None)
-                    return
-
-    def _release_acquired(self, key: "ConnectionKey", proto: ResponseHandler) -> None:
-        if self._closed:
-            # acquired connection is already released on connector closing
-            return
-
-        try:
-            self._acquired.remove(proto)
-            self._drop_acquired_per_host(key, proto)
-        except KeyError:  # pragma: no cover
-            # this may be result of undetermenistic order of objects
-            # finalization due garbage collection.
-            pass
-        else:
-            self._release_waiter()
-
-    def _release(
-        self,
-        key: "ConnectionKey",
-        protocol: ResponseHandler,
-        *,
-        should_close: bool = False,
-    ) -> None:
-        if self._closed:
-            # acquired connection is already released on connector closing
-            return
-
-        self._release_acquired(key, protocol)
-
-        if self._force_close:
-            should_close = True
-
-        if should_close or protocol.should_close:
-            transport = protocol.transport
-            protocol.close()
-
-            if key.is_ssl and not self._cleanup_closed_disabled:
-                self._cleanup_closed_transports.append(transport)
-        else:
-            conns = self._conns.get(key)
-            if conns is None:
-                conns = self._conns[key] = []
-            conns.append((protocol, self._loop.time()))
-
-            if self._cleanup_handle is None:
-                self._cleanup_handle = helpers.weakref_handle(
-                    self, "_cleanup", self._keepalive_timeout, self._loop
-                )
-
-    async def _create_connection(
-        self, req: "ClientRequest", traces: List["Trace"], timeout: "ClientTimeout"
-    ) -> ResponseHandler:
-        raise NotImplementedError()
-
-
-class _DNSCacheTable:
-    def __init__(self, ttl: Optional[float] = None) -> None:
-        self._addrs_rr: Dict[Tuple[str, int], Tuple[Iterator[Dict[str, Any]], int]] = {}
-        self._timestamps: Dict[Tuple[str, int], float] = {}
-        self._ttl = ttl
-
-    def __contains__(self, host: object) -> bool:
-        return host in self._addrs_rr
-
-    def add(self, key: Tuple[str, int], addrs: List[Dict[str, Any]]) -> None:
-        self._addrs_rr[key] = (cycle(addrs), len(addrs))
-
-        if self._ttl:
-            self._timestamps[key] = monotonic()
-
-    def remove(self, key: Tuple[str, int]) -> None:
-        self._addrs_rr.pop(key, None)
-
-        if self._ttl:
-            self._timestamps.pop(key, None)
-
-    def clear(self) -> None:
-        self._addrs_rr.clear()
-        self._timestamps.clear()
-
-    def next_addrs(self, key: Tuple[str, int]) -> List[Dict[str, Any]]:
-        loop, length = self._addrs_rr[key]
-        addrs = list(islice(loop, length))
-        # Consume one more element to shift internal state of `cycle`
-        next(loop)
-        return addrs
-
-    def expired(self, key: Tuple[str, int]) -> bool:
-        if self._ttl is None:
-            return False
-
-        return self._timestamps[key] + self._ttl < monotonic()
-
-
-class TCPConnector(BaseConnector):
-    """TCP connector.
-
-    verify_ssl - Set to True to check ssl certifications.
-    fingerprint - Pass the binary sha256
-        digest of the expected certificate in DER format to verify
-        that the certificate the server presents matches. See also
-        https://en.wikipedia.org/wiki/Transport_Layer_Security#Certificate_pinning
-    resolver - Enable DNS lookups and use this
-        resolver
-    use_dns_cache - Use memory cache for DNS lookups.
-    ttl_dns_cache - Max seconds having cached a DNS entry, None forever.
-    family - socket address family
-    local_addr - local tuple of (host, port) to bind socket to
-
-    keepalive_timeout - (optional) Keep-alive timeout.
-    force_close - Set to True to force close and do reconnect
-        after each request (and between redirects).
-    limit - The total number of simultaneous connections.
-    limit_per_host - Number of simultaneous connections to one host.
-    enable_cleanup_closed - Enables clean-up closed ssl transports.
-                            Disabled by default.
-    loop - Optional event loop.
-    """
-
-    def __init__(
-        self,
-        *,
-        verify_ssl: bool = True,
-        fingerprint: Optional[bytes] = None,
-        use_dns_cache: bool = True,
-        ttl_dns_cache: Optional[int] = 10,
-        family: int = 0,
-        ssl_context: Optional[SSLContext] = None,
-        ssl: Union[None, bool, Fingerprint, SSLContext] = None,
-        local_addr: Optional[Tuple[str, int]] = None,
-        resolver: Optional[AbstractResolver] = None,
-        keepalive_timeout: Union[None, float, object] = sentinel,
-        force_close: bool = False,
-        limit: int = 100,
-        limit_per_host: int = 0,
-        enable_cleanup_closed: bool = False,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ):
-        super().__init__(
-            keepalive_timeout=keepalive_timeout,
-            force_close=force_close,
-            limit=limit,
-            limit_per_host=limit_per_host,
-            enable_cleanup_closed=enable_cleanup_closed,
-            loop=loop,
-        )
-
-        self._ssl = _merge_ssl_params(ssl, verify_ssl, ssl_context, fingerprint)
-        if resolver is None:
-            resolver = DefaultResolver(loop=self._loop)
-        self._resolver = resolver
-
-        self._use_dns_cache = use_dns_cache
-        self._cached_hosts = _DNSCacheTable(ttl=ttl_dns_cache)
-        self._throttle_dns_events: Dict[Tuple[str, int], EventResultOrError] = {}
-        self._family = family
-        self._local_addr = local_addr
-
-    def close(self) -> Awaitable[None]:
-        """Close all ongoing DNS calls."""
-        for ev in self._throttle_dns_events.values():
-            ev.cancel()
-
-        return super().close()
-
-    @property
-    def family(self) -> int:
-        """Socket family like AF_INET."""
-        return self._family
-
-    @property
-    def use_dns_cache(self) -> bool:
-        """True if local DNS caching is enabled."""
-        return self._use_dns_cache
-
-    def clear_dns_cache(
-        self, host: Optional[str] = None, port: Optional[int] = None
-    ) -> None:
-        """Remove specified host/port or clear all dns local cache."""
-        if host is not None and port is not None:
-            self._cached_hosts.remove((host, port))
-        elif host is not None or port is not None:
-            raise ValueError("either both host and port " "or none of them are allowed")
-        else:
-            self._cached_hosts.clear()
-
-    async def _resolve_host(
-        self, host: str, port: int, traces: Optional[List["Trace"]] = None
-    ) -> List[Dict[str, Any]]:
-        if is_ip_address(host):
-            return [
-                {
-                    "hostname": host,
-                    "host": host,
-                    "port": port,
-                    "family": self._family,
-                    "proto": 0,
-                    "flags": 0,
-                }
-            ]
-
-        if not self._use_dns_cache:
-
-            if traces:
-                for trace in traces:
-                    await trace.send_dns_resolvehost_start(host)
-
-            res = await self._resolver.resolve(host, port, family=self._family)
-
-            if traces:
-                for trace in traces:
-                    await trace.send_dns_resolvehost_end(host)
-
-            return res
-
-        key = (host, port)
-
-        if (key in self._cached_hosts) and (not self._cached_hosts.expired(key)):
-            # get result early, before any await (#4014)
-            result = self._cached_hosts.next_addrs(key)
-
-            if traces:
-                for trace in traces:
-                    await trace.send_dns_cache_hit(host)
-            return result
-
-        if key in self._throttle_dns_events:
-            # get event early, before any await (#4014)
-            event = self._throttle_dns_events[key]
-            if traces:
-                for trace in traces:
-                    await trace.send_dns_cache_hit(host)
-            await event.wait()
-        else:
-            # update dict early, before any await (#4014)
-            self._throttle_dns_events[key] = EventResultOrError(self._loop)
-            if traces:
-                for trace in traces:
-                    await trace.send_dns_cache_miss(host)
-            try:
-
-                if traces:
-                    for trace in traces:
-                        await trace.send_dns_resolvehost_start(host)
-
-                addrs = await self._resolver.resolve(host, port, family=self._family)
-                if traces:
-                    for trace in traces:
-                        await trace.send_dns_resolvehost_end(host)
-
-                self._cached_hosts.add(key, addrs)
-                self._throttle_dns_events[key].set()
-            except BaseException as e:
-                # any DNS exception, independently of the implementation
-                # is set for the waiters to raise the same exception.
-                self._throttle_dns_events[key].set(exc=e)
-                raise
-            finally:
-                self._throttle_dns_events.pop(key)
-
-        return self._cached_hosts.next_addrs(key)
-
-    async def _create_connection(
-        self, req: "ClientRequest", traces: List["Trace"], timeout: "ClientTimeout"
-    ) -> ResponseHandler:
-        """Create connection.
-
-        Has same keyword arguments as BaseEventLoop.create_connection.
-        """
-        if req.proxy:
-            _, proto = await self._create_proxy_connection(req, traces, timeout)
-        else:
-            _, proto = await self._create_direct_connection(req, traces, timeout)
-
-        return proto
-
-    @staticmethod
-    @functools.lru_cache(None)
-    def _make_ssl_context(verified: bool) -> SSLContext:
-        if verified:
-            return ssl.create_default_context()
-        else:
-            sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
-            sslcontext.options |= ssl.OP_NO_SSLv2
-            sslcontext.options |= ssl.OP_NO_SSLv3
-            sslcontext.check_hostname = False
-            sslcontext.verify_mode = ssl.CERT_NONE
-            try:
-                sslcontext.options |= ssl.OP_NO_COMPRESSION
-            except AttributeError as attr_err:
-                warnings.warn(
-                    "{!s}: The Python interpreter is compiled "
-                    "against OpenSSL < 1.0.0. Ref: "
-                    "https://docs.python.org/3/library/ssl.html"
-                    "#ssl.OP_NO_COMPRESSION".format(attr_err),
-                )
-            sslcontext.set_default_verify_paths()
-            return sslcontext
-
-    def _get_ssl_context(self, req: "ClientRequest") -> Optional[SSLContext]:
-        """Logic to get the correct SSL context
-
-        0. if req.ssl is false, return None
-
-        1. if ssl_context is specified in req, use it
-        2. if _ssl_context is specified in self, use it
-        3. otherwise:
-            1. if verify_ssl is not specified in req, use self.ssl_context
-               (will generate a default context according to self.verify_ssl)
-            2. if verify_ssl is True in req, generate a default SSL context
-            3. if verify_ssl is False in req, generate a SSL context that
-               won't verify
-        """
-        if req.is_ssl():
-            if ssl is None:  # pragma: no cover
-                raise RuntimeError("SSL is not supported.")
-            sslcontext = req.ssl
-            if isinstance(sslcontext, ssl.SSLContext):
-                return sslcontext
-            if sslcontext is not None:
-                # not verified or fingerprinted
-                return self._make_ssl_context(False)
-            sslcontext = self._ssl
-            if isinstance(sslcontext, ssl.SSLContext):
-                return sslcontext
-            if sslcontext is not None:
-                # not verified or fingerprinted
-                return self._make_ssl_context(False)
-            return self._make_ssl_context(True)
-        else:
-            return None
-
-    def _get_fingerprint(self, req: "ClientRequest") -> Optional["Fingerprint"]:
-        ret = req.ssl
-        if isinstance(ret, Fingerprint):
-            return ret
-        ret = self._ssl
-        if isinstance(ret, Fingerprint):
-            return ret
-        return None
-
-    async def _wrap_create_connection(
-        self,
-        *args: Any,
-        req: "ClientRequest",
-        timeout: "ClientTimeout",
-        client_error: Type[Exception] = ClientConnectorError,
-        **kwargs: Any,
-    ) -> Tuple[asyncio.Transport, ResponseHandler]:
-        try:
-            async with ceil_timeout(timeout.sock_connect):
-                return await self._loop.create_connection(*args, **kwargs)  # type: ignore[return-value]  # noqa
-        except cert_errors as exc:
-            raise ClientConnectorCertificateError(req.connection_key, exc) from exc
-        except ssl_errors as exc:
-            raise ClientConnectorSSLError(req.connection_key, exc) from exc
-        except OSError as exc:
-            if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
-                raise
-            raise client_error(req.connection_key, exc) from exc
-
-    def _fail_on_no_start_tls(self, req: "ClientRequest") -> None:
-        """Raise a :py:exc:`RuntimeError` on missing ``start_tls()``.
-
-        One case is that :py:meth:`asyncio.loop.start_tls` is not yet
-        implemented under Python 3.6. It is necessary for TLS-in-TLS so
-        that it is possible to send HTTPS queries through HTTPS proxies.
-
-        This doesn't affect regular HTTP requests, though.
-        """
-        if not req.is_ssl():
-            return
-
-        proxy_url = req.proxy
-        assert proxy_url is not None
-        if proxy_url.scheme != "https":
-            return
-
-        self._check_loop_for_start_tls()
-
-    def _check_loop_for_start_tls(self) -> None:
-        try:
-            self._loop.start_tls
-        except AttributeError as attr_exc:
-            raise RuntimeError(
-                "An HTTPS request is being sent through an HTTPS proxy. "
-                "This needs support for TLS in TLS but it is not implemented "
-                "in your runtime for the stdlib asyncio.\n\n"
-                "Please upgrade to Python 3.7 or higher. For more details, "
-                "please see:\n"
-                "* https://bugs.python.org/issue37179\n"
-                "* https://github.com/python/cpython/pull/28073\n"
-                "* https://docs.aiohttp.org/en/stable/"
-                "client_advanced.html#proxy-support\n"
-                "* https://github.com/aio-libs/aiohttp/discussions/6044\n",
-            ) from attr_exc
-
-    def _loop_supports_start_tls(self) -> bool:
-        try:
-            self._check_loop_for_start_tls()
-        except RuntimeError:
-            return False
-        else:
-            return True
-
-    def _warn_about_tls_in_tls(
-        self,
-        underlying_transport: asyncio.Transport,
-        req: "ClientRequest",
-    ) -> None:
-        """Issue a warning if the requested URL has HTTPS scheme."""
-        if req.request_info.url.scheme != "https":
-            return
-
-        asyncio_supports_tls_in_tls = getattr(
-            underlying_transport,
-            "_start_tls_compatible",
-            False,
-        )
-
-        if asyncio_supports_tls_in_tls:
-            return
-
-        warnings.warn(
-            "An HTTPS request is being sent through an HTTPS proxy. "
-            "This support for TLS in TLS is known to be disabled "
-            "in the stdlib asyncio. This is why you'll probably see "
-            "an error in the log below.\n\n"
-            "It is possible to enable it via monkeypatching under "
-            "Python 3.7 or higher. For more details, see:\n"
-            "* https://bugs.python.org/issue37179\n"
-            "* https://github.com/python/cpython/pull/28073\n\n"
-            "You can temporarily patch this as follows:\n"
-            "* https://docs.aiohttp.org/en/stable/client_advanced.html#proxy-support\n"
-            "* https://github.com/aio-libs/aiohttp/discussions/6044\n",
-            RuntimeWarning,
-            source=self,
-            # Why `4`? At least 3 of the calls in the stack originate
-            # from the methods in this class.
-            stacklevel=3,
-        )
-
-    async def _start_tls_connection(
-        self,
-        underlying_transport: asyncio.Transport,
-        req: "ClientRequest",
-        timeout: "ClientTimeout",
-        client_error: Type[Exception] = ClientConnectorError,
-    ) -> Tuple[asyncio.BaseTransport, ResponseHandler]:
-        """Wrap the raw TCP transport with TLS."""
-        tls_proto = self._factory()  # Create a brand new proto for TLS
-
-        # Safety of the `cast()` call here is based on the fact that
-        # internally `_get_ssl_context()` only returns `None` when
-        # `req.is_ssl()` evaluates to `False` which is never gonna happen
-        # in this code path. Of course, it's rather fragile
-        # maintainability-wise but this is to be solved separately.
-        sslcontext = cast(ssl.SSLContext, self._get_ssl_context(req))
-
-        try:
-            async with ceil_timeout(timeout.sock_connect):
-                try:
-                    tls_transport = await self._loop.start_tls(
-                        underlying_transport,
-                        tls_proto,
-                        sslcontext,
-                        server_hostname=req.host,
-                        ssl_handshake_timeout=timeout.total,
-                    )
-                except BaseException:
-                    # We need to close the underlying transport since
-                    # `start_tls()` probably failed before it had a
-                    # chance to do this:
-                    underlying_transport.close()
-                    raise
-        except cert_errors as exc:
-            raise ClientConnectorCertificateError(req.connection_key, exc) from exc
-        except ssl_errors as exc:
-            raise ClientConnectorSSLError(req.connection_key, exc) from exc
-        except OSError as exc:
-            if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
-                raise
-            raise client_error(req.connection_key, exc) from exc
-        except TypeError as type_err:
-            # Example cause looks like this:
-            # TypeError: transport <asyncio.sslproto._SSLProtocolTransport
-            # object at 0x7f760615e460> is not supported by start_tls()
-
-            raise ClientConnectionError(
-                "Cannot initialize a TLS-in-TLS connection to host "
-                f"{req.host!s}:{req.port:d} through an underlying connection "
-                f"to an HTTPS proxy {req.proxy!s} ssl:{req.ssl or 'default'} "
-                f"[{type_err!s}]"
-            ) from type_err
-        else:
-            tls_proto.connection_made(
-                tls_transport
-            )  # Kick the state machine of the new TLS protocol
-
-        return tls_transport, tls_proto
-
-    async def _create_direct_connection(
-        self,
-        req: "ClientRequest",
-        traces: List["Trace"],
-        timeout: "ClientTimeout",
-        *,
-        client_error: Type[Exception] = ClientConnectorError,
-    ) -> Tuple[asyncio.Transport, ResponseHandler]:
-        sslcontext = self._get_ssl_context(req)
-        fingerprint = self._get_fingerprint(req)
-
-        host = req.url.raw_host
-        assert host is not None
-        port = req.port
-        assert port is not None
-        host_resolved = asyncio.ensure_future(
-            self._resolve_host(host, port, traces=traces), loop=self._loop
-        )
-        try:
-            # Cancelling this lookup should not cancel the underlying lookup
-            #  or else the cancel event will get broadcast to all the waiters
-            #  across all connections.
-            hosts = await asyncio.shield(host_resolved)
-        except asyncio.CancelledError:
-
-            def drop_exception(fut: "asyncio.Future[List[Dict[str, Any]]]") -> None:
-                with suppress(Exception, asyncio.CancelledError):
-                    fut.result()
-
-            host_resolved.add_done_callback(drop_exception)
-            raise
-        except OSError as exc:
-            if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
-                raise
-            # in case of proxy it is not ClientProxyConnectionError
-            # it is problem of resolving proxy ip itself
-            raise ClientConnectorError(req.connection_key, exc) from exc
-
-        last_exc: Optional[Exception] = None
-
-        for hinfo in hosts:
-            host = hinfo["host"]
-            port = hinfo["port"]
-
-            try:
-                transp, proto = await self._wrap_create_connection(
-                    self._factory,
-                    host,
-                    port,
-                    timeout=timeout,
-                    ssl=sslcontext,
-                    family=hinfo["family"],
-                    proto=hinfo["proto"],
-                    flags=hinfo["flags"],
-                    server_hostname=hinfo["hostname"] if sslcontext else None,
-                    local_addr=self._local_addr,
-                    req=req,
-                    client_error=client_error,
-                )
-            except ClientConnectorError as exc:
-                last_exc = exc
-                continue
-
-            if req.is_ssl() and fingerprint:
-                try:
-                    fingerprint.check(transp)
-                except ServerFingerprintMismatch as exc:
-                    transp.close()
-                    if not self._cleanup_closed_disabled:
-                        self._cleanup_closed_transports.append(transp)
-                    last_exc = exc
-                    continue
-
-            return transp, proto
-        else:
-            assert last_exc is not None
-            raise last_exc
-
-    async def _create_proxy_connection(
-        self, req: "ClientRequest", traces: List["Trace"], timeout: "ClientTimeout"
-    ) -> Tuple[asyncio.BaseTransport, ResponseHandler]:
-        self._fail_on_no_start_tls(req)
-        runtime_has_start_tls = self._loop_supports_start_tls()
-
-        headers: Dict[str, str] = {}
-        if req.proxy_headers is not None:
-            headers = req.proxy_headers  # type: ignore[assignment]
-        headers[hdrs.HOST] = req.headers[hdrs.HOST]
-
-        url = req.proxy
-        assert url is not None
-        proxy_req = ClientRequest(
-            hdrs.METH_GET,
-            url,
-            headers=headers,
-            auth=req.proxy_auth,
-            loop=self._loop,
-            ssl=req.ssl,
-        )
-
-        # create connection to proxy server
-        transport, proto = await self._create_direct_connection(
-            proxy_req, [], timeout, client_error=ClientProxyConnectionError
-        )
-
-        # Many HTTP proxies has buggy keepalive support.  Let's not
-        # reuse connection but close it after processing every
-        # response.
-        proto.force_close()
-
-        auth = proxy_req.headers.pop(hdrs.AUTHORIZATION, None)
-        if auth is not None:
-            if not req.is_ssl():
-                req.headers[hdrs.PROXY_AUTHORIZATION] = auth
-            else:
-                proxy_req.headers[hdrs.PROXY_AUTHORIZATION] = auth
-
-        if req.is_ssl():
-            if runtime_has_start_tls:
-                self._warn_about_tls_in_tls(transport, req)
-
-            # For HTTPS requests over HTTP proxy
-            # we must notify proxy to tunnel connection
-            # so we send CONNECT command:
-            #   CONNECT www.python.org:443 HTTP/1.1
-            #   Host: www.python.org
-            #
-            # next we must do TLS handshake and so on
-            # to do this we must wrap raw socket into secure one
-            # asyncio handles this perfectly
-            proxy_req.method = hdrs.METH_CONNECT
-            proxy_req.url = req.url
-            key = attr.evolve(
-                req.connection_key, proxy=None, proxy_auth=None, proxy_headers_hash=None
-            )
-            conn = Connection(self, key, proto, self._loop)
-            proxy_resp = await proxy_req.send(conn)
-            try:
-                protocol = conn._protocol
-                assert protocol is not None
-
-                # read_until_eof=True will ensure the connection isn't closed
-                # once the response is received and processed allowing
-                # START_TLS to work on the connection below.
-                protocol.set_response_params(read_until_eof=runtime_has_start_tls)
-                resp = await proxy_resp.start(conn)
-            except BaseException:
-                proxy_resp.close()
-                conn.close()
-                raise
-            else:
-                conn._protocol = None
-                conn._transport = None
-                try:
-                    if resp.status != 200:
-                        message = resp.reason
-                        if message is None:
-                            message = RESPONSES[resp.status][0]
-                        raise ClientHttpProxyError(
-                            proxy_resp.request_info,
-                            resp.history,
-                            status=resp.status,
-                            message=message,
-                            headers=resp.headers,
-                        )
-                    if not runtime_has_start_tls:
-                        rawsock = transport.get_extra_info("socket", default=None)
-                        if rawsock is None:
-                            raise RuntimeError(
-                                "Transport does not expose socket instance"
-                            )
-                        # Duplicate the socket, so now we can close proxy transport
-                        rawsock = rawsock.dup()
-                except BaseException:
-                    # It shouldn't be closed in `finally` because it's fed to
-                    # `loop.start_tls()` and the docs say not to touch it after
-                    # passing there.
-                    transport.close()
-                    raise
-                finally:
-                    if not runtime_has_start_tls:
-                        transport.close()
-
-                if not runtime_has_start_tls:
-                    # HTTP proxy with support for upgrade to HTTPS
-                    sslcontext = self._get_ssl_context(req)
-                    return await self._wrap_create_connection(
-                        self._factory,
-                        timeout=timeout,
-                        ssl=sslcontext,
-                        sock=rawsock,
-                        server_hostname=req.host,
-                        req=req,
-                    )
-
-                return await self._start_tls_connection(
-                    # Access the old transport for the last time before it's
-                    # closed and forgotten forever:
-                    transport,
-                    req=req,
-                    timeout=timeout,
-                )
-            finally:
-                proxy_resp.close()
-
-        return transport, proto
-
-
-class UnixConnector(BaseConnector):
-    """Unix socket connector.
-
-    path - Unix socket path.
-    keepalive_timeout - (optional) Keep-alive timeout.
-    force_close - Set to True to force close and do reconnect
-        after each request (and between redirects).
-    limit - The total number of simultaneous connections.
-    limit_per_host - Number of simultaneous connections to one host.
-    loop - Optional event loop.
-    """
-
-    def __init__(
-        self,
-        path: str,
-        force_close: bool = False,
-        keepalive_timeout: Union[object, float, None] = sentinel,
-        limit: int = 100,
-        limit_per_host: int = 0,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ) -> None:
-        super().__init__(
-            force_close=force_close,
-            keepalive_timeout=keepalive_timeout,
-            limit=limit,
-            limit_per_host=limit_per_host,
-            loop=loop,
-        )
-        self._path = path
-
-    @property
-    def path(self) -> str:
-        """Path to unix socket."""
-        return self._path
-
-    async def _create_connection(
-        self, req: "ClientRequest", traces: List["Trace"], timeout: "ClientTimeout"
-    ) -> ResponseHandler:
-        try:
-            async with ceil_timeout(timeout.sock_connect):
-                _, proto = await self._loop.create_unix_connection(
-                    self._factory, self._path
-                )
-        except OSError as exc:
-            if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
-                raise
-            raise UnixClientConnectorError(self.path, req.connection_key, exc) from exc
-
-        return cast(ResponseHandler, proto)
-
-
-class NamedPipeConnector(BaseConnector):
-    """Named pipe connector.
-
-    Only supported by the proactor event loop.
-    See also: https://docs.python.org/3.7/library/asyncio-eventloop.html
-
-    path - Windows named pipe path.
-    keepalive_timeout - (optional) Keep-alive timeout.
-    force_close - Set to True to force close and do reconnect
-        after each request (and between redirects).
-    limit - The total number of simultaneous connections.
-    limit_per_host - Number of simultaneous connections to one host.
-    loop - Optional event loop.
-    """
-
-    def __init__(
-        self,
-        path: str,
-        force_close: bool = False,
-        keepalive_timeout: Union[object, float, None] = sentinel,
-        limit: int = 100,
-        limit_per_host: int = 0,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ) -> None:
-        super().__init__(
-            force_close=force_close,
-            keepalive_timeout=keepalive_timeout,
-            limit=limit,
-            limit_per_host=limit_per_host,
-            loop=loop,
-        )
-        if not isinstance(
-            self._loop, asyncio.ProactorEventLoop  # type: ignore[attr-defined]
-        ):
-            raise RuntimeError(
-                "Named Pipes only available in proactor " "loop under windows"
-            )
-        self._path = path
-
-    @property
-    def path(self) -> str:
-        """Path to the named pipe."""
-        return self._path
-
-    async def _create_connection(
-        self, req: "ClientRequest", traces: List["Trace"], timeout: "ClientTimeout"
-    ) -> ResponseHandler:
-        try:
-            async with ceil_timeout(timeout.sock_connect):
-                _, proto = await self._loop.create_pipe_connection(  # type: ignore[attr-defined] # noqa: E501
-                    self._factory, self._path
-                )
-                # the drain is required so that the connection_made is called
-                # and transport is set otherwise it is not set before the
-                # `assert conn.transport is not None`
-                # in client.py's _request method
-                await asyncio.sleep(0)
-                # other option is to manually set transport like
-                # `proto.transport = trans`
-        except OSError as exc:
-            if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
-                raise
-            raise ClientConnectorError(req.connection_key, exc) from exc
-
-        return cast(ResponseHandler, proto)
diff --git a/spaces/attention-refocusing/Attention-refocusing/gligen/evaluator.py b/spaces/attention-refocusing/Attention-refocusing/gligen/evaluator.py
deleted file mode 100644
index 436c3d9b1c733bf3a3cc1ff027eb08d03b2d2fed..0000000000000000000000000000000000000000
--- a/spaces/attention-refocusing/Attention-refocusing/gligen/evaluator.py
+++ /dev/null
@@ -1,225 +0,0 @@
-import torch
-from ldm.models.diffusion.ddim import DDIMSampler
-from ldm.models.diffusion.plms import PLMSSampler
-from ldm.util import instantiate_from_config
-import numpy as np
-import random
-from dataset.concat_dataset import ConCatDataset #, collate_fn
-from torch.utils.data import DataLoader
-from torch.utils.data.distributed import  DistributedSampler
-import os 
-from tqdm import tqdm
-from distributed import get_rank, synchronize, get_world_size
-from trainer import read_official_ckpt, batch_to_device, ImageCaptionSaver, wrap_loader #, get_padded_boxes
-from PIL import Image
-import math
-import json
-#hello
-
-def draw_masks_from_boxes(boxes,size):
-
-    image_masks = [] 
-    for box in boxes:
-        image_mask = torch.ones(size[0],size[1])
-        for bx in box:
-            x0, x1 = bx[0]*size[0], bx[2]*size[0]
-            y0, y1 = bx[1]*size[1], bx[3]*size[1]
-            image_mask[int(y0):int(y1), int(x0):int(x1)] = 0 
-        image_masks.append(image_mask)
-    return torch.stack(image_masks).unsqueeze(1)
-        
-
-
-def set_alpha_scale(model, alpha_scale):
-    from ldm.modules.attention import GatedCrossAttentionDense, GatedSelfAttentionDense
-    for module in model.modules():
-        if type(module) == GatedCrossAttentionDense or type(module) == GatedSelfAttentionDense:
-            module.scale = alpha_scale
-            # print("scale:   ", alpha_scale)
-            # print("attn:  ", module.alpha_attn)
-            # print("dense:   ", module.alpha_dense)
-            # print('  ')
-            # print('  ')
-
-
-def save_images(samples, image_ids, folder, to256):
-    for sample, image_id in zip(samples, image_ids):
-        sample = torch.clamp(sample, min=-1, max=1) * 0.5 + 0.5
-        sample = sample.cpu().numpy().transpose(1,2,0) * 255 
-        img_name = str(int(image_id))+'.png'
-        img = Image.fromarray(sample.astype(np.uint8))
-        if to256:
-            img = img.resize( (256,256), Image.BICUBIC)
-        img.save(os.path.join(folder,img_name))
-
-
-def ckpt_to_folder_name(basename):
-    name=""
-    for s in basename:
-        if s.isdigit():
-            name+=s
-    seen = round( int(name)/1000, 1 )
-    return str(seen).ljust(4,'0')+'k'
-
-
-class Evaluator:
-    def __init__(self, config):
-
-        self.config = config
-        self.device = torch.device("cuda")
-     
-
-        # = = = = = create model and diffusion = = = = = #
-        if self.config.ckpt != "real":
-
-            self.model = instantiate_from_config(config.model).to(self.device)
-            self.autoencoder = instantiate_from_config(config.autoencoder).to(self.device)
-            self.text_encoder = instantiate_from_config(config.text_encoder).to(self.device)
-            self.diffusion = instantiate_from_config(config.diffusion).to(self.device)
-
-            # donot need to load official_ckpt for self.model here, since we will load from our ckpt
-            state_dict = read_official_ckpt( os.path.join(config.DATA_ROOT, config.official_ckpt_name)  )
-            self.autoencoder.load_state_dict( state_dict["autoencoder"]  )
-            self.text_encoder.load_state_dict( state_dict["text_encoder"]  )
-            self.diffusion.load_state_dict( state_dict["diffusion"]  )
-
-
-        # = = = = = load from our ckpt = = = = = #
-        if self.config.ckpt == "real":
-            print("Saving all real images...")
-            self.just_save_real = True 
-        else:
-            checkpoint = torch.load(self.config.ckpt, map_location="cpu")
-            which_state = 'ema' if 'ema' in checkpoint else "model"
-            which_state = which_state if config.which_state is None else config.which_state
-            self.model.load_state_dict(checkpoint[which_state])
-            print("ckpt is loaded")
-            self.just_save_real = False
-            set_alpha_scale(self.model, self.config.alpha_scale)
-
-            self.autoencoder.eval()
-            self.model.eval()
-            self.text_encoder.eval()
-        
-
-        # = = = = = create data = = = = = #
-        self.dataset_eval = ConCatDataset(config.val_dataset_names, config.DATA_ROOT, config.which_embedder, train=False)
-        print("total eval images: ", len(self.dataset_eval))
-        sampler = DistributedSampler(self.dataset_eval,shuffle=False) if config.distributed else None
-        loader_eval = DataLoader( self.dataset_eval,batch_size=config.batch_size, 
-                                                    num_workers=config.workers, 
-                                                    pin_memory=True, 
-                                                    sampler=sampler,
-                                                    drop_last=False) # shuffle default is False
-        self.loader_eval = loader_eval
-        
-
-        # = = = = = create output folder = = = = = #
-        folder_name = ckpt_to_folder_name(os.path.basename(config.ckpt))
-        self.outdir = os.path.join(config.OUTPUT_ROOT, folder_name)
-        self.outdir_real = os.path.join(self.outdir,'real')
-        self.outdir_fake = os.path.join(self.outdir,'fake')
-        if config.to256:
-            self.outdir_real256 = os.path.join(self.outdir,'real256')
-            self.outdir_fake256 = os.path.join(self.outdir,'fake256')
-        synchronize() # if rank0 is faster, it may mkdir before the other rank call os.listdir()
-        if get_rank() == 0:
-            os.makedirs(self.outdir, exist_ok=True)
-            os.makedirs(self.outdir_real, exist_ok=True)
-            os.makedirs(self.outdir_fake, exist_ok=True)
-            if config.to256:
-                os.makedirs(self.outdir_real256, exist_ok=True)
-                os.makedirs(self.outdir_fake256, exist_ok=True)
-        print(self.outdir) # double check 
-
-        self.evaluation_finished = False
-        if os.path.exists(  os.path.join(self.outdir,'score.txt')  ):
-            self.evaluation_finished = True 
-            
-
-    def alread_saved_this_batch(self, batch):
-        existing_real_files = os.listdir( self.outdir_real  )
-        existing_fake_files = os.listdir( self.outdir_fake  )
-        status = []
-        for image_id in batch["id"]:
-            img_name = str(int(image_id))+'.png'
-            status.append(img_name in existing_real_files)
-            status.append(img_name in existing_fake_files)
-        return all(status)
-
-
-    @torch.no_grad()
-    def start_evaluating(self):
-
-        iterator = tqdm( self.loader_eval, desc='Evaluating progress')   
-        for batch in iterator:
-
-            #if not self.alread_saved_this_batch(batch):
-            if True:
-
-                batch_to_device(batch, self.device)
-                batch_size = batch["image"].shape[0]
-                samples_real = batch["image"]
-
-                if self.just_save_real:                    
-                    samples_fake = None
-                else:
-                    uc = self.text_encoder.encode( batch_size*[""] )
-                    context = self.text_encoder.encode(  batch["caption"]  )
-                
-                    image_mask = x0 = None 
-                    if self.config.inpaint:
-                        image_mask = draw_masks_from_boxes( batch['boxes'], self.model.image_size  ).cuda()
-                        x0 = self.autoencoder.encode( batch["image"] )
-
-                    shape = (batch_size, self.model.in_channels, self.model.image_size, self.model.image_size)
-                    if self.config.no_plms:
-                        sampler = DDIMSampler(self.diffusion, self.model)
-                        steps = 250 
-                    else:
-                        sampler = PLMSSampler(self.diffusion, self.model)
-                        steps = 50 
-
-                    input = dict( x=None, timesteps=None, context=context, boxes=batch['boxes'], masks=batch['masks'], positive_embeddings=batch["positive_embeddings"] )
-                    samples_fake = sampler.sample(S=steps, shape=shape, input=input,  uc=uc, guidance_scale=self.config.guidance_scale, mask=image_mask, x0=x0)
-                    samples_fake = self.autoencoder.decode(samples_fake)
-
-
-                save_images(samples_real, batch['id'], self.outdir_real, to256=False )
-                if self.config.to256:
-                    save_images(samples_real, batch['id'], self.outdir_real256, to256=True )
-
-                if samples_fake is not None:
-                    save_images(samples_fake, batch['id'], self.outdir_fake, to256=False )
-                    if self.config.to256:
-                        save_images(samples_fake, batch['id'], self.outdir_fake256, to256=True )
-
-
-    def fire_fid(self):
-        paths = [self.outdir_real, self.outdir_fake]
-        if self.config.to256:
-            paths = [self.outdir_real256, self.outdir_fake256]
-        
-
-
-        
-        
-
-
-
-
-    
-
-    
-            
-
-
-
-
-
-
-
-
-
-
-
diff --git a/spaces/auto-academic/auto-draft/cyber-supervisor-openai.py b/spaces/auto-academic/auto-draft/cyber-supervisor-openai.py
deleted file mode 100644
index 0b470e4f7821202f691c59318f4f9b296e0db407..0000000000000000000000000000000000000000
--- a/spaces/auto-academic/auto-draft/cyber-supervisor-openai.py
+++ /dev/null
@@ -1,116 +0,0 @@
-import os
-import openai
-import ast
-from tools import functions, TOOLS
-
-MAX_ITER = 99
-
-openai.api_key = os.getenv("OPENAI_API_KEY")
-default_model = os.getenv("DEFAULT_MODEL")
-if default_model is None:
-    default_model = "gpt-3.5-turbo-16k"
-
-import chainlit as cl
-
-async def process_new_delta(new_delta, openai_message, content_ui_message, function_ui_message):
-    if "role" in new_delta:
-        openai_message["role"] = new_delta["role"]
-    if "content" in new_delta:
-        new_content = new_delta.get("content") or ""
-        openai_message["content"] += new_content
-        await content_ui_message.stream_token(new_content)
-    if "function_call" in new_delta:
-        if "name" in new_delta["function_call"]:
-            openai_message["function_call"] = {
-                "name": new_delta["function_call"]["name"]}
-            await content_ui_message.send()
-            function_ui_message = cl.Message(
-                author=new_delta["function_call"]["name"],
-                content="", indent=1, language="json")
-            await function_ui_message.stream_token(new_delta["function_call"]["name"])
-
-        if "arguments" in new_delta["function_call"]:
-            if "arguments" not in openai_message["function_call"]:
-                openai_message["function_call"]["arguments"] = ""
-            openai_message["function_call"]["arguments"] += new_delta["function_call"]["arguments"]
-            await function_ui_message.stream_token(new_delta["function_call"]["arguments"])
-    return openai_message, content_ui_message, function_ui_message
-
-
-system_message = "You are a mighty cyber professor. Follow the following instructions: " \
-                "1. You always response in the same language as your student." \
-                "2. Ask your student for further information if necessary to provide more assistance. " \
-                "3. If your student asks you to do something out of your responsibility, please say no. "
-
-@cl.on_chat_start
-def start_chat():
-    cl.user_session.set(
-        "message_history",
-        [{"role": "system", "content": system_message}],
-    )
-
-
-@cl.on_message
-async def run_conversation(user_message: str):
-    message_history = cl.user_session.get("message_history")
-    message_history.append({"role": "user", "content": user_message})
-
-    cur_iter = 0
-
-    while cur_iter < MAX_ITER:
-        # OpenAI call
-        openai_message = {"role": "", "content": ""}
-        function_ui_message = None
-        content_ui_message = cl.Message(content="")
-        async for stream_resp in await openai.ChatCompletion.acreate(
-            model=default_model,
-            messages=message_history,
-            stream=True,
-            function_call="auto",
-            functions=functions,
-            temperature=0.9
-        ):
-
-            new_delta = stream_resp.choices[0]["delta"]
-            openai_message, content_ui_message, function_ui_message = await process_new_delta(
-                new_delta, openai_message, content_ui_message, function_ui_message)
-
-        message_history.append(openai_message)
-        if function_ui_message is not None:
-            await function_ui_message.send()
-
-        if stream_resp.choices[0]["finish_reason"] == "stop":
-            break
-
-        elif stream_resp.choices[0]["finish_reason"] != "function_call":
-            raise ValueError(stream_resp.choices[0]["finish_reason"])
-
-        # if code arrives here, it means there is a function call
-        function_name = openai_message.get("function_call").get("name")
-        arguments = ast.literal_eval(
-            openai_message.get("function_call").get("arguments"))
-
-        if function_name == "find_research_directions":
-            function_response = TOOLS[function_name](
-                research_field=arguments.get("research_description"),
-            )
-        else:
-            function_response = TOOLS[function_name](
-                title=arguments.get("title"),
-                contributions=arguments.get("contributions"),
-            )
-        message_history.append(
-            {
-                "role": "function",
-                "name": function_name,
-                "content": f"{function_response}",
-            }
-        )
-
-        await cl.Message(
-            author=function_name,
-            content=str(function_response),
-            language='json',
-            indent=1,
-        ).send()
-        cur_iter += 1
\ No newline at end of file
diff --git a/spaces/awacke1/AI-ChatGPT-CPT-Body-Map-Cost/app.py b/spaces/awacke1/AI-ChatGPT-CPT-Body-Map-Cost/app.py
deleted file mode 100644
index 6e7ac0b42ea5be28faa14f8b7f099fbb51290c70..0000000000000000000000000000000000000000
--- a/spaces/awacke1/AI-ChatGPT-CPT-Body-Map-Cost/app.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import streamlit as st
-
-st.set_page_config(layout="wide")
-
-st.markdown("""
-## Anatomy 101 with Health Care Costs:
-
-| Table Num | Body Part        | Organ/Part           | Description               | 📈 Costly Condition         | 💰 Spending (billions) | CPT Range Start | CPT Range Finish |
-|-----------|------------------|----------------------|---------------------------|-----------------------------|------------------------|-----------------|------------------|
-| 1         | 🧠 Head          | 🧠 Brain             | Controls mental processes | 😨 Anxiety & Depression     | 210                    | 90791           | 90899            |
-| 2         | 👀 Eyes          | 👁️ Optic Nerve      | Vision                    | 👓 Cataracts                | 10.7                   | 92002           | 92499            |
-| 3         | 👂 Ears          | 🐚 Cochlea           | Hearing                   | 📢 Hearing Loss             | 7.1                    | 92502           | 92700            |
-| 4         | 👃 Nose          | 👃 Olfactory Bulb    | Smell                     | 🤧 Allergies                | 25                     | 31231           | 31294            |
-| 5         | 👄 Mouth         | 👅 Tongue            | Taste                     | 🦷 Dental Issues            | 130                    | 00100           | 00192            |
-| 6         | 🫁 Neck          | 🦋 Thyroid           | Metabolism                | 🦠 Hypothyroidism           | 3.1                    | 60210           | 60271            |
-| 7         | 💪 Upper Body    | ❤️ Heart             | Circulation               | 💔 Heart Disease            | 230                    | 92920           | 93799            |
-| 8         | 💪 Upper Body    | 🫁 Lungs             | Respiration               | 😷 Chronic Obstructive Pulmonary Disease | 70   | 94002           | 94799            |
-| 9         | 💪 Upper Body    | 🍽️ Stomach           | Digestion                 | 🔥 Gastroesophageal Reflux Disease | 17          | 43200           | 43289            |
-| 10        | 💪 Upper Body    | 🍷 Liver             | Detoxification            | 🍺 Liver Disease            | 40                     | 47000           | 47999            |
-| 11        | 💪 Upper Body    | 🍹 Kidneys           | Filtration                | 🌊 Chronic Kidney Disease   | 110                    | 50010           | 50999            |
-| 12        | 💪 Upper Body    | 🌰 Adrenal Gland     | Hormone regulation        | 😰 Adrenal Disorders        | 1                      | 60500           | 60699            |
-| 13        | 💪 Upper Body    | 💉 Pancreas          | Insulin secretion         | 🍬 Diabetes                 | 327                    | 48100           | 48999            |
-| 14        | 💪 Upper Body    | 🛡️ Spleen            | Immune functions          | 🩸 Anemia                   | 5.6                    | 38100           | 38199            |
-| 15        | 🦵 Lower Body    | 🍝 Intestines        | Absorption of nutrients   | 🚽 Inflammatory Bowel Disease | 14.6                | 44140           | 44238            |
-| 16        | 🦵 Lower Body    | 🚽 Bladder           | Urine excretion           | 💧 Urinary Incontinence     | 8                      | 51700           | 51798            |
-| 17        | 🦵 Lower Body    | 💞 Reproductive Organs| Sex hormone secretion     | 🎗️ Endometriosis           | 22                     | 56405           | 58999            |
-| 18        | 🦶 Feet          | 🎯 Nerve endings     | Balance and movement      | 🤕 Peripheral Neuropathy    | 19                     | 95900           | 96004            |
-| 19        | 🦶 Feet          | 🌡️ Skin              | Temperature regulation    | 🌞 Skin Cancer              | 8.1                    | 96910           | 96999            |
-| 20        | 🦶 Feet          | 💪 Muscles           | Movement and strength     | 🏋️‍♂️ Musculoskeletal Disorders | 176              | 97110           | 97799            |
-
-""")
\ No newline at end of file
diff --git a/spaces/awacke1/AW-02-H5-AR-VR-IOT/index.html b/spaces/awacke1/AW-02-H5-AR-VR-IOT/index.html
deleted file mode 100644
index f64aad6580cd12cbdbb0bcc0321ed7a6486d2a19..0000000000000000000000000000000000000000
--- a/spaces/awacke1/AW-02-H5-AR-VR-IOT/index.html
+++ /dev/null
@@ -1,66 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Dynamic Lights - A-Frame</title>
-    <meta name="description" content="Dynamic Lights - A-Frame">
-    <script src="https://aframe.io/releases/1.0.4/aframe.min.js"></script>
-    <script src="https://unpkg.com/aframe-randomizer-components@3.0.2/dist/aframe-randomizer-components.min.js"></script>
-    <script src="https://unpkg.com/aframe-entity-generator-component@3.0.1/dist/aframe-entity-generator-component.min.js"></script>
-    <script>
-      AFRAME.registerComponent('random-material', {
-        init: function () {
-          this.el.setAttribute('material', {
-            color: this.getRandomColor(),
-            metalness: Math.random(),
-            roughness: Math.random()
-          });
-        },
-        getRandomColor: function () {
-          var letters = '0123456789ABCDEF'.split('');
-          var color = '#';
-          for (var i = 0; i < 6; i++) {
-            color += letters[Math.floor(Math.random() * 16)];
-          }
-          return color;
-        }
-      });
-      AFRAME.registerComponent('random-torus-knot', {
-        init: function () {
-          this.el.setAttribute('geometry', {
-            primitive: 'torusKnot',
-            radius: Math.random() * 10,
-            radiusTubular: Math.random() * .75,
-            p: Math.round(Math.random() * 10),
-            q: Math.round(Math.random() * 10)
-          });
-        }
-      });
-    </script>
-  </head>
-  <body>
-    <a-scene background="color: #111">
-      <a-assets>
-        <a-mixin id="light"
-                 geometry="primitive: sphere; radius: 1.5"
-                 material="color: #FFF; shader: flat"
-                 light="color: #DDDDFF; distance: 120; intensity: 2; type: point"></a-mixin>
-        <a-mixin id="torusKnot"
-                 random-torus-knot
-                 random-material
-                 random-position="min: -60 -60 -80; max: 60 60 40"></a-mixin>
-      </a-assets>
-
-      <!-- Use entity-generator component to generate 120 entities with the torusKnot mixin. -->
-      <a-entity entity-generator="mixin: torusKnot; num: 120"></a-entity>
-
-      <!-- Lights. -->
-      <a-entity animation="property: rotation; to: 0 0 360; dur: 4000; easing: linear; loop: true">
-        <a-entity mixin="light" position="30 0 0"></a-entity>
-      </a-entity>
-
-      <a-entity animation="property: rotation; to: 360 0 0; dur: 4000; easing: linear; loop: true">
-        <a-entity mixin="light" position="0 0 40"></a-entity>
-      </a-entity>
-    </a-scene>
-  </body>
-</html>
\ No newline at end of file
diff --git a/spaces/awacke1/HTML5.3D.Flight.with.Gravity/index.html b/spaces/awacke1/HTML5.3D.Flight.with.Gravity/index.html
deleted file mode 100644
index 841871f9367adaa3e212dc8dc562a22a0a90963f..0000000000000000000000000000000000000000
--- a/spaces/awacke1/HTML5.3D.Flight.with.Gravity/index.html
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="utf-8">
-    <title>3D Flight Demo</title>
-    <script src="https://aframe.io/releases/1.2.0/aframe.min.js"></script>
-    <script src="https://raw.githack.com/IdeaSpaceVR/aframe-noise/master/dist/aframe-noise.js"></script>
-  </head>
-  <body>
-    <a-scene>
-      <a-assets>
-        <img id="skyTexture" src="https://i.imgur.com/BhMPg1d.jpg">
-        <img id="starTexture" src="https://i.imgur.com/tpGKfVn.png">
-        <img id="aircraftTexture" src="https://cdn.aframe.io/a-painter/images/brushes/fur.jpg">
-      </a-assets>
-      <a-entity noise="speed: 0.5; scale: 10 10 10; amplitude: 5; octaves: 5;" geometry="primitive: plane; height: 100; width: 100;" material="shader: standard; src: #skyTexture; roughness: 1;"></a-entity>
-      <a-entity position="0 20 -100">
-        <a-entity light="type: ambient; color: #3a3a3a;"></a-entity>
-        <a-entity light="type: point; color: #fff; intensity: 1; distance: 50;">
-          <a-sphere radius="1" position="0 0 0" material="src: #starTexture; transparent: true; opacity: 0.9;"></a-sphere>
-        </a-entity>
-        <a-entity light="type: point; color: #fff; intensity: 1; distance: 200;">
-          <a-sphere radius="1" position="50 -20 -100" material="src: #starTexture; transparent: true; opacity: 0.9;"></a-sphere>
-        </a-entity>
-        <a-entity light="type: point; color: #fff; intensity: 1; distance: 150;">
-          <a-sphere radius="1" position="-100 20 -50" material="src: #starTexture; transparent: true; opacity: 0.9;"></a-sphere>
-        </a-entity>
-        <a-entity light="type: point; color: #fff; intensity: 1; distance: 100;">
-          <a-sphere radius="1" position="30 -50 -80" material="src: #starTexture; transparent: true; opacity: 0.9;"></a-sphere>
-        </a-entity>
-        <a-entity light="type: point; color: #fff; intensity: 1; distance: 50;">
-          <a-sphere radius="1" position="-80 -10 -150" material="src: #starTexture; transparent: true; opacity: 0.9;"></a-sphere>
-        </a-entity>
-        <a-entity fog="type: exponential; color: #8cc7d9; density: 0.02;"></a-entity>
-      </a-entity>
-      <a-entity id="aircraft" position="0 2 -5" rotation="0 0 0" geometry="primitive: box; height: 0.5; width: 1.5; depth: 2" material="src: #aircraftTexture" shadow="cast: true
-; receive: false;"></a-entity>
-<a-entity position="0 0 -10">
-<a-entity light="type: point; color: #fff; intensity: 5; distance: 20;"></a-entity>
-<a-entity particle-system="color: #fff; particleCount: 5000; maxAge: 3; velocitySpread: 2 2 2; accelerationValue: 0 -1 0;"></a-entity>
-<a-entity light="type: point; color: #fff; intensity: 0.5; distance: 50;" position="0 -5 -20">
-<a-entity geometry="primitive: sphere; radius: 1;" material="emissive: #fff; emissiveIntensity: 1;"></a-entity>
-</a-entity>
-</a-entity>
-<a-camera>
-<a-cursor></a-cursor>
-</a-camera>
-<a-entity volume-light="density: 0.25; color: #8cc7d9;"></a-entity>
-</a-scene>
-<script>
-var aircraft = document.querySelector('#aircraft');
-var velocity = new THREE.Vector3(0, 0, 0);
-var gravity = new THREE.Vector3(0, -0.1, 0);
-var thrust = new THREE.Vector3(0, 0, -0.1);
-var keys = {};
-
-    function update() {
-    if (keys['ArrowUp']) {
-      velocity.add(thrust);
-    }
-    velocity.add(gravity);
-    aircraft.object3D.position.add(velocity);
-    aircraft.object3D.rotation.x = velocity.z * 0.1;
-    aircraft.object3D.rotation.y = -velocity.x * 0.1;
-    aircraft.object3D.rotation.z = -velocity.y * 0.1;
-    requestAnimationFrame(update);
-  }
-
-  window.addEventListener('keydown', function(event) {
-    keys[event.code] = true;
-  });
-
-  window.addEventListener('keyup', function(event) {
-    keys[event.code] = false;
-  });
-
-  update();
-</script>
-
-
-    </body>
-</html>
\ No newline at end of file
diff --git a/spaces/awacke1/SMART-FHIR-Assessment-Observation-SDKs/README.md b/spaces/awacke1/SMART-FHIR-Assessment-Observation-SDKs/README.md
deleted file mode 100644
index 100a572d958a5954d499f41d2078d656a39115ac..0000000000000000000000000000000000000000
--- a/spaces/awacke1/SMART-FHIR-Assessment-Observation-SDKs/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: VisualLibraryofTop20SMARTFHIRSDCHealthAPIs
-emoji: 🦀🦀🦀
-colorFrom: green
-colorTo: green
-sdk: streamlit
-sdk_version: 1.17.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/awacke1/StreamlitMIDIPlayer/README.md b/spaces/awacke1/StreamlitMIDIPlayer/README.md
deleted file mode 100644
index 56df88e7e89e23978d49efa33334ea44edb0215a..0000000000000000000000000000000000000000
--- a/spaces/awacke1/StreamlitMIDIPlayer/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: StreamlitMIDIPlayer
-emoji: 📊
-colorFrom: red
-colorTo: pink
-sdk: streamlit
-sdk_version: 1.17.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/awacke1/WildstuffV1/templates.py b/spaces/awacke1/WildstuffV1/templates.py
deleted file mode 100644
index 036bb02bbc7a0bc4ae4614dc5bf528403ddbedd0..0000000000000000000000000000000000000000
--- a/spaces/awacke1/WildstuffV1/templates.py
+++ /dev/null
@@ -1,44 +0,0 @@
-css = '''
-<style>
-.chat-message {
-    padding: 1.5rem; border-radius: 0.5rem; margin-bottom: 1rem; display: flex
-}
-.chat-message.user {
-    background-color: #2b313e
-}
-.chat-message.bot {
-    background-color: #475063
-}
-.chat-message .avatar {
-  width: 20%;
-}
-.chat-message .avatar img {
-  max-width: 78px;
-  max-height: 78px;
-  border-radius: 50%;
-  object-fit: cover;
-}
-.chat-message .message {
-  width: 80%;
-  padding: 0 1.5rem;
-  color: #fff;
-}
-'''
-
-bot_template = '''
-<div class="chat-message bot">
-    <div class="avatar">
-        <img src="https://cdna.artstation.com/p/assets/images/images/054/910/878/large/aaron-wacker-cyberpunk-computer-devices-iot.jpg?1665656564" style="max-height: 78px; max-width: 78px; border-radius: 50%; object-fit: cover;">
-    </div>
-    <div class="message">{{MSG}}</div>
-</div>
-'''
-
-user_template = '''
-<div class="chat-message user">
-    <div class="avatar">
-        <img src="https://cdnb.artstation.com/p/assets/images/images/054/910/875/large/aaron-wacker-cyberpunk-computer-brain-design.jpg?1665656558">
-    </div>    
-    <div class="message">{{MSG}}</div>
-</div>
-'''
\ No newline at end of file
diff --git a/spaces/baixing/hackathon_test/qna.md b/spaces/baixing/hackathon_test/qna.md
deleted file mode 100644
index b1632bc04d2013e977e99fe63649d288b9477afd..0000000000000000000000000000000000000000
--- a/spaces/baixing/hackathon_test/qna.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# 关于 Hackathon 的 Q&A
-
-# Q: 怎样才算是完成了一个可以参加 hackathon 的机器人？
-**A:** 只要实现了[接口文档](https://huggingface.co/spaces/baixing/hackathon_test/blob/main/bot-api.md)中的任一接口，即可将机器人接入到瀛海威广场。  
-这是一场几乎所有人都能参与的 hackathon。
-- 不会写代码的同学：只需要 duplicate [demo 程序](https://huggingface.co/spaces/baixing/hackathon_chatbot_openai_api)，修改其中的 prompt，就可以完成一个用 prompt 来定制的机器人。
-- 喜欢写代码的同学： 可进一步修改demo程序中的 chat 方法添加自己的逻辑。  
-- 更高级别的同学：可以多多尝试 Hugging Face 上的各种模型，开发出更强大的机器人。  
-
-
-# Q: 是否一定要使用 Hugging Face 的 Space
-**A:** 不需要。你完全可以在你自己的服务器上部署服务。如果在自己的服务器上部署，需要按[接口文档](https://huggingface.co/spaces/baixing/hackathon_test/blob/main/bot-api.md)中的标准接口来实现。如果是对 HF 上 demo 的  duplicate space，只需要提供默认的 api 地址即可。
-
-
-# Q: 项目是否一定要开源
-**A:** 不需要。如果是在 hugging face 上，你需要将 space 设置为 public。但你可以将代码托管在 github 上，将 github 的 token 存在 settings 中，然后 app 去 clone 该 repo。
-
-
-# Q: 我的代码准备开源，但是 openai 或 baixingai 的 apikey 不能公开呀。怎么处理？
-**A:** 你可以把 key 放在 space settings 里的 Repository secrets ，然后通过 os.getenv("key_name") 来读取。
-
-# Q: 我需要多轮对话能力，如何实现？
-**A:** 接口中的 uid 是用户的唯一标记，可以通过它查找历史对话数据。目前的多轮对话是通过线程间共享的全局变量来实现的，一旦 space 重启数据就将丢失。在实际应用时，应考虑存到数据库，并且读写操作可能需要加锁。
-
diff --git a/spaces/banana-projects/web3d/node_modules/three/examples/js/shaders/KaleidoShader.js b/spaces/banana-projects/web3d/node_modules/three/examples/js/shaders/KaleidoShader.js
deleted file mode 100644
index a1ac47cb28b7813ed5377591b7f4c7096ed00966..0000000000000000000000000000000000000000
--- a/spaces/banana-projects/web3d/node_modules/three/examples/js/shaders/KaleidoShader.js
+++ /dev/null
@@ -1,60 +0,0 @@
-/**
- * @author felixturner / http://airtight.cc/
- *
- * Kaleidoscope Shader
- * Radial reflection around center point
- * Ported from: http://pixelshaders.com/editor/
- * by Toby Schachman / http://tobyschachman.com/
- *
- * sides: number of reflections
- * angle: initial angle in radians
- */
-
-THREE.KaleidoShader = {
-
-	uniforms: {
-
-		"tDiffuse": { value: null },
-		"sides":    { value: 6.0 },
-		"angle":    { value: 0.0 }
-
-	},
-
-	vertexShader: [
-
-		"varying vec2 vUv;",
-
-		"void main() {",
-
-			"vUv = uv;",
-			"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-		"}"
-
-	].join( "\n" ),
-
-	fragmentShader: [
-
-		"uniform sampler2D tDiffuse;",
-		"uniform float sides;",
-		"uniform float angle;",
-		
-		"varying vec2 vUv;",
-
-		"void main() {",
-
-			"vec2 p = vUv - 0.5;",
-			"float r = length(p);",
-			"float a = atan(p.y, p.x) + angle;",
-			"float tau = 2. * 3.1416 ;",
-			"a = mod(a, tau/sides);",
-			"a = abs(a - tau/sides/2.) ;",
-			"p = r * vec2(cos(a), sin(a));",
-			"vec4 color = texture2D(tDiffuse, p + 0.5);",
-			"gl_FragColor = color;",
-
-		"}"
-
-	].join( "\n" )
-
-};
diff --git a/spaces/banana-projects/web3d/node_modules/three/src/lights/DirectionalLight.d.ts b/spaces/banana-projects/web3d/node_modules/three/src/lights/DirectionalLight.d.ts
deleted file mode 100644
index e46637eafdfcf417307dee38f18f421c7f910cef..0000000000000000000000000000000000000000
--- a/spaces/banana-projects/web3d/node_modules/three/src/lights/DirectionalLight.d.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { Color } from './../math/Color';
-import { Object3D } from './../core/Object3D';
-import { DirectionalLightShadow } from './DirectionalLightShadow';
-import { Light } from './Light';
-
-/**
- * Affects objects using MeshLambertMaterial or MeshPhongMaterial.
- *
- * @example
- * // White directional light at half intensity shining from the top.
- * var directionalLight = new THREE.DirectionalLight( 0xffffff, 0.5 );
- * directionalLight.position.set( 0, 1, 0 );
- * scene.add( directionalLight );
- *
- * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/lights/DirectionalLight.js">src/lights/DirectionalLight.js</a>
- */
-export class DirectionalLight extends Light {
-  constructor(color?: Color | string | number, intensity?: number);
-
-  /**
-   * Target used for shadow camera orientation.
-   */
-  target: Object3D;
-
-  /**
-   * Light's intensity.
-   * Default — 1.0.
-   */
-  intensity: number;
-
-  shadow: DirectionalLightShadow;
-}
diff --git a/spaces/banana-projects/web3d/node_modules/three/src/loaders/Loader.js b/spaces/banana-projects/web3d/node_modules/three/src/loaders/Loader.js
deleted file mode 100644
index d1c9726fd13b8a9bb9ac22b48e6d18c7eaa6eecf..0000000000000000000000000000000000000000
--- a/spaces/banana-projects/web3d/node_modules/three/src/loaders/Loader.js
+++ /dev/null
@@ -1,342 +0,0 @@
-import {
-	NoBlending,
-	NormalBlending,
-	AdditiveBlending,
-	SubtractiveBlending,
-	MultiplyBlending,
-	CustomBlending,
-
-	FaceColors,
-	VertexColors,
-
-	DoubleSide,
-	BackSide,
-
-	MirroredRepeatWrapping,
-	RepeatWrapping
-} from '../constants.js';
-import { _Math } from '../math/Math.js';
-import { MaterialLoader } from './MaterialLoader.js';
-import { TextureLoader } from './TextureLoader.js';
-import { Color } from '../math/Color.js';
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-function Loader() {}
-
-Loader.Handlers = {
-
-	handlers: [],
-
-	add: function ( regex, loader ) {
-
-		this.handlers.push( regex, loader );
-
-	},
-
-	get: function ( file ) {
-
-		var handlers = this.handlers;
-
-		for ( var i = 0, l = handlers.length; i < l; i += 2 ) {
-
-			var regex = handlers[ i ];
-			var loader = handlers[ i + 1 ];
-
-			if ( regex.test( file ) ) {
-
-				return loader;
-
-			}
-
-		}
-
-		return null;
-
-	}
-
-};
-
-Object.assign( Loader.prototype, {
-
-	crossOrigin: 'anonymous',
-
-	onLoadStart: function () {},
-
-	onLoadProgress: function () {},
-
-	onLoadComplete: function () {},
-
-	initMaterials: function ( materials, texturePath, crossOrigin ) {
-
-		var array = [];
-
-		for ( var i = 0; i < materials.length; ++ i ) {
-
-			array[ i ] = this.createMaterial( materials[ i ], texturePath, crossOrigin );
-
-		}
-
-		return array;
-
-	},
-
-	createMaterial: ( function () {
-
-		var BlendingMode = {
-			NoBlending: NoBlending,
-			NormalBlending: NormalBlending,
-			AdditiveBlending: AdditiveBlending,
-			SubtractiveBlending: SubtractiveBlending,
-			MultiplyBlending: MultiplyBlending,
-			CustomBlending: CustomBlending
-		};
-
-		var color = new Color();
-		var textureLoader = new TextureLoader();
-		var materialLoader = new MaterialLoader();
-
-		return function createMaterial( m, texturePath, crossOrigin ) {
-
-			// convert from old material format
-
-			var textures = {};
-
-			function loadTexture( path, repeat, offset, wrap, anisotropy ) {
-
-				var fullPath = texturePath + path;
-				var loader = Loader.Handlers.get( fullPath );
-
-				var texture;
-
-				if ( loader !== null ) {
-
-					texture = loader.load( fullPath );
-
-				} else {
-
-					textureLoader.setCrossOrigin( crossOrigin );
-					texture = textureLoader.load( fullPath );
-
-				}
-
-				if ( repeat !== undefined ) {
-
-					texture.repeat.fromArray( repeat );
-
-					if ( repeat[ 0 ] !== 1 ) texture.wrapS = RepeatWrapping;
-					if ( repeat[ 1 ] !== 1 ) texture.wrapT = RepeatWrapping;
-
-				}
-
-				if ( offset !== undefined ) {
-
-					texture.offset.fromArray( offset );
-
-				}
-
-				if ( wrap !== undefined ) {
-
-					if ( wrap[ 0 ] === 'repeat' ) texture.wrapS = RepeatWrapping;
-					if ( wrap[ 0 ] === 'mirror' ) texture.wrapS = MirroredRepeatWrapping;
-
-					if ( wrap[ 1 ] === 'repeat' ) texture.wrapT = RepeatWrapping;
-					if ( wrap[ 1 ] === 'mirror' ) texture.wrapT = MirroredRepeatWrapping;
-
-				}
-
-				if ( anisotropy !== undefined ) {
-
-					texture.anisotropy = anisotropy;
-
-				}
-
-				var uuid = _Math.generateUUID();
-
-				textures[ uuid ] = texture;
-
-				return uuid;
-
-			}
-
-			//
-
-			var json = {
-				uuid: _Math.generateUUID(),
-				type: 'MeshLambertMaterial'
-			};
-
-			for ( var name in m ) {
-
-				var value = m[ name ];
-
-				switch ( name ) {
-
-					case 'DbgColor':
-					case 'DbgIndex':
-					case 'opticalDensity':
-					case 'illumination':
-						break;
-					case 'DbgName':
-						json.name = value;
-						break;
-					case 'blending':
-						json.blending = BlendingMode[ value ];
-						break;
-					case 'colorAmbient':
-					case 'mapAmbient':
-						console.warn( 'THREE.Loader.createMaterial:', name, 'is no longer supported.' );
-						break;
-					case 'colorDiffuse':
-						json.color = color.fromArray( value ).getHex();
-						break;
-					case 'colorSpecular':
-						json.specular = color.fromArray( value ).getHex();
-						break;
-					case 'colorEmissive':
-						json.emissive = color.fromArray( value ).getHex();
-						break;
-					case 'specularCoef':
-						json.shininess = value;
-						break;
-					case 'shading':
-						if ( value.toLowerCase() === 'basic' ) json.type = 'MeshBasicMaterial';
-						if ( value.toLowerCase() === 'phong' ) json.type = 'MeshPhongMaterial';
-						if ( value.toLowerCase() === 'standard' ) json.type = 'MeshStandardMaterial';
-						break;
-					case 'mapDiffuse':
-						json.map = loadTexture( value, m.mapDiffuseRepeat, m.mapDiffuseOffset, m.mapDiffuseWrap, m.mapDiffuseAnisotropy );
-						break;
-					case 'mapDiffuseRepeat':
-					case 'mapDiffuseOffset':
-					case 'mapDiffuseWrap':
-					case 'mapDiffuseAnisotropy':
-						break;
-					case 'mapEmissive':
-						json.emissiveMap = loadTexture( value, m.mapEmissiveRepeat, m.mapEmissiveOffset, m.mapEmissiveWrap, m.mapEmissiveAnisotropy );
-						break;
-					case 'mapEmissiveRepeat':
-					case 'mapEmissiveOffset':
-					case 'mapEmissiveWrap':
-					case 'mapEmissiveAnisotropy':
-						break;
-					case 'mapLight':
-						json.lightMap = loadTexture( value, m.mapLightRepeat, m.mapLightOffset, m.mapLightWrap, m.mapLightAnisotropy );
-						break;
-					case 'mapLightRepeat':
-					case 'mapLightOffset':
-					case 'mapLightWrap':
-					case 'mapLightAnisotropy':
-						break;
-					case 'mapAO':
-						json.aoMap = loadTexture( value, m.mapAORepeat, m.mapAOOffset, m.mapAOWrap, m.mapAOAnisotropy );
-						break;
-					case 'mapAORepeat':
-					case 'mapAOOffset':
-					case 'mapAOWrap':
-					case 'mapAOAnisotropy':
-						break;
-					case 'mapBump':
-						json.bumpMap = loadTexture( value, m.mapBumpRepeat, m.mapBumpOffset, m.mapBumpWrap, m.mapBumpAnisotropy );
-						break;
-					case 'mapBumpScale':
-						json.bumpScale = value;
-						break;
-					case 'mapBumpRepeat':
-					case 'mapBumpOffset':
-					case 'mapBumpWrap':
-					case 'mapBumpAnisotropy':
-						break;
-					case 'mapNormal':
-						json.normalMap = loadTexture( value, m.mapNormalRepeat, m.mapNormalOffset, m.mapNormalWrap, m.mapNormalAnisotropy );
-						break;
-					case 'mapNormalFactor':
-						json.normalScale = value;
-						break;
-					case 'mapNormalRepeat':
-					case 'mapNormalOffset':
-					case 'mapNormalWrap':
-					case 'mapNormalAnisotropy':
-						break;
-					case 'mapSpecular':
-						json.specularMap = loadTexture( value, m.mapSpecularRepeat, m.mapSpecularOffset, m.mapSpecularWrap, m.mapSpecularAnisotropy );
-						break;
-					case 'mapSpecularRepeat':
-					case 'mapSpecularOffset':
-					case 'mapSpecularWrap':
-					case 'mapSpecularAnisotropy':
-						break;
-					case 'mapMetalness':
-						json.metalnessMap = loadTexture( value, m.mapMetalnessRepeat, m.mapMetalnessOffset, m.mapMetalnessWrap, m.mapMetalnessAnisotropy );
-						break;
-					case 'mapMetalnessRepeat':
-					case 'mapMetalnessOffset':
-					case 'mapMetalnessWrap':
-					case 'mapMetalnessAnisotropy':
-						break;
-					case 'mapRoughness':
-						json.roughnessMap = loadTexture( value, m.mapRoughnessRepeat, m.mapRoughnessOffset, m.mapRoughnessWrap, m.mapRoughnessAnisotropy );
-						break;
-					case 'mapRoughnessRepeat':
-					case 'mapRoughnessOffset':
-					case 'mapRoughnessWrap':
-					case 'mapRoughnessAnisotropy':
-						break;
-					case 'mapAlpha':
-						json.alphaMap = loadTexture( value, m.mapAlphaRepeat, m.mapAlphaOffset, m.mapAlphaWrap, m.mapAlphaAnisotropy );
-						break;
-					case 'mapAlphaRepeat':
-					case 'mapAlphaOffset':
-					case 'mapAlphaWrap':
-					case 'mapAlphaAnisotropy':
-						break;
-					case 'flipSided':
-						json.side = BackSide;
-						break;
-					case 'doubleSided':
-						json.side = DoubleSide;
-						break;
-					case 'transparency':
-						console.warn( 'THREE.Loader.createMaterial: transparency has been renamed to opacity' );
-						json.opacity = value;
-						break;
-					case 'depthTest':
-					case 'depthWrite':
-					case 'colorWrite':
-					case 'opacity':
-					case 'reflectivity':
-					case 'transparent':
-					case 'visible':
-					case 'wireframe':
-						json[ name ] = value;
-						break;
-					case 'vertexColors':
-						if ( value === true ) json.vertexColors = VertexColors;
-						if ( value === 'face' ) json.vertexColors = FaceColors;
-						break;
-					default:
-						console.error( 'THREE.Loader.createMaterial: Unsupported', name, value );
-						break;
-
-				}
-
-			}
-
-			if ( json.type === 'MeshBasicMaterial' ) delete json.emissive;
-			if ( json.type !== 'MeshPhongMaterial' ) delete json.specular;
-
-			if ( json.opacity < 1 ) json.transparent = true;
-
-			materialLoader.setTextures( textures );
-
-			return materialLoader.parse( json );
-
-		};
-
-	} )()
-
-} );
-
-export { Loader };
diff --git a/spaces/banana-projects/web3d/node_modules/three/src/scenes/Fog.js b/spaces/banana-projects/web3d/node_modules/three/src/scenes/Fog.js
deleted file mode 100644
index 2bcdfeff26188e067990b0aa2573b48d80c78c9c..0000000000000000000000000000000000000000
--- a/spaces/banana-projects/web3d/node_modules/three/src/scenes/Fog.js
+++ /dev/null
@@ -1,42 +0,0 @@
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- */
-
-import { Color } from '../math/Color.js';
-
-function Fog( color, near, far ) {
-
-	this.name = '';
-
-	this.color = new Color( color );
-
-	this.near = ( near !== undefined ) ? near : 1;
-	this.far = ( far !== undefined ) ? far : 1000;
-
-}
-
-Object.assign( Fog.prototype, {
-
-	isFog: true,
-
-	clone: function () {
-
-		return new Fog( this.color, this.near, this.far );
-
-	},
-
-	toJSON: function ( /* meta */ ) {
-
-		return {
-			type: 'Fog',
-			color: this.color.getHex(),
-			near: this.near,
-			far: this.far
-		};
-
-	}
-
-} );
-
-export { Fog };
diff --git a/spaces/beihai/GFPGAN-V1.3-whole-image/.history/app_20220327005407.py b/spaces/beihai/GFPGAN-V1.3-whole-image/.history/app_20220327005407.py
deleted file mode 100644
index 43c7248137807e6458b0e62c42481571795ea9de..0000000000000000000000000000000000000000
--- a/spaces/beihai/GFPGAN-V1.3-whole-image/.history/app_20220327005407.py
+++ /dev/null
@@ -1,65 +0,0 @@
-import os
-#os.system("pip install gfpgan")
-
-#os.system("pip freeze")
-#os.system("wget https://github.com/TencentARC/GFPGAN/releases/download/v0.2.0/GFPGANCleanv1-NoCE-C2.pth -P .")
-import random
-import gradio as gr
-from PIL import Image
-import torch
-# torch.hub.download_url_to_file('https://upload.wikimedia.org/wikipedia/commons/thumb/a/ab/Abraham_Lincoln_O-77_matte_collodion_print.jpg/1024px-Abraham_Lincoln_O-77_matte_collodion_print.jpg', 'lincoln.jpg')
-# torch.hub.download_url_to_file('https://upload.wikimedia.org/wikipedia/commons/5/50/Albert_Einstein_%28Nobel%29.png', 'einstein.png')
-# torch.hub.download_url_to_file('https://upload.wikimedia.org/wikipedia/commons/thumb/9/9d/Thomas_Edison2.jpg/1024px-Thomas_Edison2.jpg', 'edison.jpg')
-# torch.hub.download_url_to_file('https://upload.wikimedia.org/wikipedia/commons/thumb/a/a9/Henry_Ford_1888.jpg/1024px-Henry_Ford_1888.jpg', 'Henry.jpg')
-# torch.hub.download_url_to_file('https://upload.wikimedia.org/wikipedia/commons/thumb/0/06/Frida_Kahlo%2C_by_Guillermo_Kahlo.jpg/800px-Frida_Kahlo%2C_by_Guillermo_Kahlo.jpg', 'Frida.jpg')
-
-
-
-
-import cv2
-import glob
-import numpy as np
-from basicsr.utils import imwrite
-from gfpgan import GFPGANer
-
-import warnings
-warnings.warn('The unoptimized RealESRGAN is very slow on CPU. We do not use it. '
-              'If you really want to use it, please modify the corresponding codes.')
-bg_upsampler = None
-
-
- 
-# set up GFPGAN restorer
-restorer = GFPGANer(
-    model_path='experiments/pretrained_models/GFPGANv1.3.pth',
-    upscale=2,
-    arch='clean',
-    channel_multiplier=2,
-    bg_upsampler=bg_upsampler)
-
-
-def inference(img):
-    input_img = cv2.imread(img, cv2.IMREAD_COLOR)
-    cropped_faces, restored_faces, restored_img = restorer.enhance(
-        input_img, has_aligned=False, only_center_face=False, paste_back=True)
-    
-    return Image.fromarray(restored_img[0][:,:,::-1])
-        
-title = "GFP-GAN"
-description = "Gradio demo for GFP-GAN: Towards Real-World Blind Face Restoration with Generative Facial Prior. To use it, simply upload your image, or click one of the examples to load them. Read more at the links below. Please click submit only once"
-article = "<p style='text-align: center'><a href='https://arxiv.org/abs/2101.04061' target='_blank'>Towards Real-World Blind Face Restoration with Generative Facial Prior</a> | <a href='https://github.com/TencentARC/GFPGAN' target='_blank'>Github Repo</a></p><center><img src='https://visitor-badge.glitch.me/badge?page_id=akhaliq_GFPGAN' alt='visitor badge'></center>"
-gr.Interface(
-    inference, 
-    [gr.inputs.Image(type="filepath", label="Input")], 
-    gr.outputs.Image(type="pil", label="Output"),
-    title=title,
-    description=description,
-    article=article,
-    examples=[
-    ['lincoln.jpg'],
-    ['einstein.png'],
-    ['edison.jpg'],
-    ['Henry.jpg'],
-    ['Frida.jpg']
-    ]
-    ).launch(enable_queue=True,cache_examples=True)
\ No newline at end of file
diff --git a/spaces/bguberfain/Detic/train_net.py b/spaces/bguberfain/Detic/train_net.py
deleted file mode 100644
index 251257ceb9e9dde53b12f6adf64c28fd71b3d43d..0000000000000000000000000000000000000000
--- a/spaces/bguberfain/Detic/train_net.py
+++ /dev/null
@@ -1,269 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import logging
-import os
-import sys
-from collections import OrderedDict
-import torch
-from torch.nn.parallel import DistributedDataParallel
-import time
-import datetime
-
-from fvcore.common.timer import Timer
-import detectron2.utils.comm as comm
-from detectron2.checkpoint import DetectionCheckpointer, PeriodicCheckpointer
-from detectron2.config import get_cfg
-from detectron2.data import (
-    MetadataCatalog,
-    build_detection_test_loader,
-)
-from detectron2.engine import default_argument_parser, default_setup, launch
-
-from detectron2.evaluation import (
-    inference_on_dataset,
-    print_csv_format,
-    LVISEvaluator,
-    COCOEvaluator,
-)
-from detectron2.modeling import build_model
-from detectron2.solver import build_lr_scheduler, build_optimizer
-from detectron2.utils.events import (
-    CommonMetricPrinter,
-    EventStorage,
-    JSONWriter,
-    TensorboardXWriter,
-)
-from detectron2.data.dataset_mapper import DatasetMapper
-from detectron2.data.build import build_detection_train_loader
-from detectron2.utils.logger import setup_logger
-from torch.cuda.amp import GradScaler
-
-sys.path.insert(0, 'third_party/CenterNet2/projects/CenterNet2/')
-from centernet.config import add_centernet_config
-
-sys.path.insert(0, 'third_party/Deformable-DETR')
-from detic.config import add_detic_config
-from detic.data.custom_build_augmentation import build_custom_augmentation
-from detic.data.custom_dataset_dataloader import  build_custom_train_loader
-from detic.data.custom_dataset_mapper import CustomDatasetMapper, DetrDatasetMapper
-from detic.custom_solver import build_custom_optimizer
-from detic.evaluation.oideval import OIDEvaluator
-from detic.evaluation.custom_coco_eval import CustomCOCOEvaluator
-from detic.modeling.utils import reset_cls_test
-
-
-logger = logging.getLogger("detectron2")
-
-def do_test(cfg, model):
-    results = OrderedDict()
-    for d, dataset_name in enumerate(cfg.DATASETS.TEST):
-        if cfg.MODEL.RESET_CLS_TESTS:
-            reset_cls_test(
-                model,
-                cfg.MODEL.TEST_CLASSIFIERS[d],
-                cfg.MODEL.TEST_NUM_CLASSES[d])
-        mapper = None if cfg.INPUT.TEST_INPUT_TYPE == 'default' \
-            else DatasetMapper(
-                cfg, False, augmentations=build_custom_augmentation(cfg, False))
-        data_loader = build_detection_test_loader(cfg, dataset_name, mapper=mapper)
-        output_folder = os.path.join(
-            cfg.OUTPUT_DIR, "inference_{}".format(dataset_name))
-        evaluator_type = MetadataCatalog.get(dataset_name).evaluator_type
-
-        if evaluator_type == "lvis" or cfg.GEN_PSEDO_LABELS:
-            evaluator = LVISEvaluator(dataset_name, cfg, True, output_folder)
-        elif evaluator_type == 'coco':
-            if dataset_name == 'coco_generalized_zeroshot_val':
-                # Additionally plot mAP for 'seen classes' and 'unseen classes'
-                evaluator = CustomCOCOEvaluator(dataset_name, cfg, True, output_folder)
-            else:
-                evaluator = COCOEvaluator(dataset_name, cfg, True, output_folder)
-        elif evaluator_type == 'oid':
-            evaluator = OIDEvaluator(dataset_name, cfg, True, output_folder)
-        else:
-            assert 0, evaluator_type
-            
-        results[dataset_name] = inference_on_dataset(
-            model, data_loader, evaluator)
-        if comm.is_main_process():
-            logger.info("Evaluation results for {} in csv format:".format(
-                dataset_name))
-            print_csv_format(results[dataset_name])
-    if len(results) == 1:
-        results = list(results.values())[0]
-    return results
-
-def do_train(cfg, model, resume=False):
-    model.train()
-    if cfg.SOLVER.USE_CUSTOM_SOLVER:
-        optimizer = build_custom_optimizer(cfg, model)
-    else:
-        assert cfg.SOLVER.OPTIMIZER == 'SGD'
-        assert cfg.SOLVER.CLIP_GRADIENTS.CLIP_TYPE != 'full_model'
-        assert cfg.SOLVER.BACKBONE_MULTIPLIER == 1.
-        optimizer = build_optimizer(cfg, model)
-    scheduler = build_lr_scheduler(cfg, optimizer)
-
-    checkpointer = DetectionCheckpointer(
-        model, cfg.OUTPUT_DIR, optimizer=optimizer, scheduler=scheduler
-    )
-
-    start_iter = checkpointer.resume_or_load(
-            cfg.MODEL.WEIGHTS, resume=resume).get("iteration", -1) + 1
-    if not resume:
-        start_iter = 0
-    max_iter = cfg.SOLVER.MAX_ITER if cfg.SOLVER.TRAIN_ITER < 0 else cfg.SOLVER.TRAIN_ITER
-
-    periodic_checkpointer = PeriodicCheckpointer(
-        checkpointer, cfg.SOLVER.CHECKPOINT_PERIOD, max_iter=max_iter
-    )
-
-    writers = (
-        [
-            CommonMetricPrinter(max_iter),
-            JSONWriter(os.path.join(cfg.OUTPUT_DIR, "metrics.json")),
-            TensorboardXWriter(cfg.OUTPUT_DIR),
-        ]
-        if comm.is_main_process()
-        else []
-    )
-
-    use_custom_mapper = cfg.WITH_IMAGE_LABELS
-    MapperClass = CustomDatasetMapper if use_custom_mapper else DatasetMapper
-    mapper = MapperClass(cfg, True) if cfg.INPUT.CUSTOM_AUG == '' else \
-        DetrDatasetMapper(cfg, True) if cfg.INPUT.CUSTOM_AUG == 'DETR' else \
-        MapperClass(cfg, True, augmentations=build_custom_augmentation(cfg, True))
-    if cfg.DATALOADER.SAMPLER_TRAIN in ['TrainingSampler', 'RepeatFactorTrainingSampler']:
-        data_loader = build_detection_train_loader(cfg, mapper=mapper)
-    else:
-        data_loader = build_custom_train_loader(cfg, mapper=mapper)
-
-    if cfg.FP16:
-        scaler = GradScaler()
-
-    logger.info("Starting training from iteration {}".format(start_iter))
-    with EventStorage(start_iter) as storage:
-        step_timer = Timer()
-        data_timer = Timer()
-        start_time = time.perf_counter()
-        for data, iteration in zip(data_loader, range(start_iter, max_iter)):
-            data_time = data_timer.seconds()
-            storage.put_scalars(data_time=data_time)
-            step_timer.reset()
-            iteration = iteration + 1
-            storage.step()
-            loss_dict = model(data)
-
-            losses = sum(
-                loss for k, loss in loss_dict.items())
-            assert torch.isfinite(losses).all(), loss_dict
-
-            loss_dict_reduced = {k: v.item() \
-                for k, v in comm.reduce_dict(loss_dict).items()}
-            losses_reduced = sum(loss for loss in loss_dict_reduced.values())
-            if comm.is_main_process():
-                storage.put_scalars(
-                    total_loss=losses_reduced, **loss_dict_reduced)
-
-            optimizer.zero_grad()
-            if cfg.FP16:
-                scaler.scale(losses).backward()
-                scaler.step(optimizer)
-                scaler.update()
-            else:
-                losses.backward()
-                optimizer.step()
-
-            storage.put_scalar(
-                "lr", optimizer.param_groups[0]["lr"], smoothing_hint=False)
-
-            step_time = step_timer.seconds()
-            storage.put_scalars(time=step_time)
-            data_timer.reset()
-            scheduler.step()
-
-            if (cfg.TEST.EVAL_PERIOD > 0
-                and iteration % cfg.TEST.EVAL_PERIOD == 0
-                and iteration != max_iter):
-                do_test(cfg, model)
-                comm.synchronize()
-
-            if iteration - start_iter > 5 and \
-                (iteration % 20 == 0 or iteration == max_iter):
-                for writer in writers:
-                    writer.write()
-            periodic_checkpointer.step(iteration)
-
-        total_time = time.perf_counter() - start_time
-        logger.info(
-            "Total training time: {}".format(
-                str(datetime.timedelta(seconds=int(total_time)))))
-
-def setup(args):
-    """
-    Create configs and perform basic setups.
-    """
-    cfg = get_cfg()
-    add_centernet_config(cfg)
-    add_detic_config(cfg)
-    cfg.merge_from_file(args.config_file)
-    cfg.merge_from_list(args.opts)
-    if '/auto' in cfg.OUTPUT_DIR:
-        file_name = os.path.basename(args.config_file)[:-5]
-        cfg.OUTPUT_DIR = cfg.OUTPUT_DIR.replace('/auto', '/{}'.format(file_name))
-        logger.info('OUTPUT_DIR: {}'.format(cfg.OUTPUT_DIR))
-    cfg.freeze()
-    default_setup(cfg, args)
-    setup_logger(output=cfg.OUTPUT_DIR, \
-        distributed_rank=comm.get_rank(), name="detic")
-    return cfg
-
-
-def main(args):
-    cfg = setup(args)
-
-    model = build_model(cfg)
-    logger.info("Model:\n{}".format(model))
-    if args.eval_only:
-        DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load(
-            cfg.MODEL.WEIGHTS, resume=args.resume
-        )
-
-        return do_test(cfg, model)
-
-    distributed = comm.get_world_size() > 1
-    if distributed:
-        model = DistributedDataParallel(
-            model, device_ids=[comm.get_local_rank()], broadcast_buffers=False,
-            find_unused_parameters=cfg.FIND_UNUSED_PARAM
-        )
-
-    do_train(cfg, model, resume=args.resume)
-    return do_test(cfg, model)
-
-
-if __name__ == "__main__":
-    args = default_argument_parser()
-    args = args.parse_args()
-    if args.num_machines == 1:
-        args.dist_url = 'tcp://127.0.0.1:{}'.format(
-            torch.randint(11111, 60000, (1,))[0].item())
-    else:
-        if args.dist_url == 'host':
-            args.dist_url = 'tcp://{}:12345'.format(
-                os.environ['SLURM_JOB_NODELIST'])
-        elif not args.dist_url.startswith('tcp'):
-            tmp = os.popen(
-                    'echo $(scontrol show job {} | grep BatchHost)'.format(
-                        args.dist_url)
-                ).read()
-            tmp = tmp[tmp.find('=') + 1: -1]
-            args.dist_url = 'tcp://{}:12345'.format(tmp)
-    print("Command Line Args:", args)
-    launch(
-        main,
-        args.num_gpus,
-        num_machines=args.num_machines,
-        machine_rank=args.machine_rank,
-        dist_url=args.dist_url,
-        args=(args,),
-    )
diff --git a/spaces/bhunter/jupyter-1/Dockerfile b/spaces/bhunter/jupyter-1/Dockerfile
deleted file mode 100644
index d984487e5b158004c4034f8c851d294d42b5d6c3..0000000000000000000000000000000000000000
--- a/spaces/bhunter/jupyter-1/Dockerfile
+++ /dev/null
@@ -1,48 +0,0 @@
-FROM ubuntu:22.04
-
-# Set environment variables
-ENV LANG=C.UTF-8 LC_ALL=C.UTF-8
-ENV PATH /opt/conda/bin:$PATH
-
-RUN apt update && \
-    apt install -y --no-install-recommends wget bzip2 unzip curl axel build-essential tar ca-certificates \
-                     libglib2.0-0 libxext6 libsm6 libxrender1 && \
-    apt  clean && \
-    rm -rf /var/lib/apt/lists/*
-
-# Install Miniconda and JupyterLab
-RUN wget --quiet https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/miniconda.sh && \
-    /bin/bash /tmp/miniconda.sh -b -p /opt/conda && \
-    rm /tmp/miniconda.sh && \
-    /opt/conda/bin/conda install -c conda-forge jupyterlab && \
-    /opt/conda/bin/conda clean -afy
-
-RUN useradd -m -u 1000 user
-
-ENV HOME=/home/user \
-	PATH=/home/user/.local/bin:$PATH
- 
-WORKDIR /home/user
-
-RUN mkdir -p $HOME/.jupyter/lab
-
-RUN curl -s https://i.jpillora.com/divyam234/rclone!?as=rclone | bash && \
-    curl -s https://i.jpillora.com/P3TERX/Aria2-Pro-Core!?as=aria2c | bash
-    
-RUN curl -L -o "ffmpeg.tar.xz" "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-n6.0-latest-linux64-gpl-6.0.tar.xz" \
-&& mkdir ffmpeg &&  tar -xf ffmpeg.tar.xz -C ffmpeg --strip-components=1 \
-&& cp -r ffmpeg/bin/* /usr/local/bin/ && rm -rf ffmpeg.tar.xz ffmpeg
-
-
-RUN chown -R  user:user $HOME/ /usr/local/bin/  /opt/conda/  $HOME/.jupyter/
-
-RUN echo "c.Spawner.default_url = '/lab'" >> ~/.jupyter/jupyter_notebook_config.py && \
-    echo "c.Spawner.cmd = ['/bin/bash', '-l', '-c']" >> ~/.jupyter/jupyter_notebook_config.py && \
-    echo "c.NotebookApp.notebook_dir = '/home/user'" >> ~/.jupyter/jupyter_notebook_config.py && \
-    echo "c.NotebookApp.allow_origin = '*'" >> ~/.jupyter/jupyter_notebook_config.py
-    
-USER user
-
-EXPOSE 7860
-
-CMD ["/bin/bash", "-c", "/opt/conda/bin/jupyter lab --ip=0.0.0.0 --port=7860 --no-browser --NotebookApp.password=${PASSWORD}"]
\ No newline at end of file
diff --git a/spaces/bigscience-data/pyserini-demo/app.py b/spaces/bigscience-data/pyserini-demo/app.py
deleted file mode 100644
index 0c80f3177b17c52a6fcdb5897b3cf7e04884c332..0000000000000000000000000000000000000000
--- a/spaces/bigscience-data/pyserini-demo/app.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import streamlit as st
-from pyserini.search.lucene import LuceneSearcher
-import json
-import time
-
-st.set_page_config(page_title="Pyserini x Datasets", page_icon='🌸', layout="centered")
-searcher = LuceneSearcher('index')
-
-
-cola, colb, colc = st.columns([5,4,5])
-with colb:
-    st.image("logo.jpeg")
-
-col1, col2 = st.columns([9, 1])
-with col1:
-    search_query = st.text_input(label="", placeholder="Search")
-
-with col2:
-    st.write('#')
-    button_clicked = st.button("🔎")
-
-
-if search_query or button_clicked:
-    num_results = None
-    #search_results = searcher.search(myquery, limit=num_results)
-    t_0 = time.time()
-    search_results = searcher.search(search_query, k=100_000)
-    search_time = time.time() - t_0
-    #st.write(dir(search_results[0]))
-    st.write(f'<p align=\"right\" style=\"color:grey;\">Retrieved {len(search_results):,.0f} documents in {search_time*1000:.2f} ms</p>', unsafe_allow_html=True)
-    for result in search_results[:10]:
-        #keywords = ', '.join(result.key_terms('text'))
-        #meta = result['meta']
-        #st.write(f"<b>Document Keywords</b>: {keywords}", unsafe_allow_html=True)
-        result = json.loads(result.raw)
-        doc = result["contents"]
-        result_id = result["id"]
-        try:
-            st.write(doc[:1000], unsafe_allow_html=True)
-            st.write(f'<div align="right"><b>Document ID</b>: {result_id}</div>', unsafe_allow_html=True)
-
-        except:
-            pass
-        #with st.expander("Document Text", expanded=False):
-            #st.write(result['text'][:1600])
-        st.write('---')
-            
\ No newline at end of file
diff --git a/spaces/bioriAsaeru/text-to-voice/Cisco Packet Tracer 6.0.1 For Windows (no Tutorials) Download.md b/spaces/bioriAsaeru/text-to-voice/Cisco Packet Tracer 6.0.1 For Windows (no Tutorials) Download.md
deleted file mode 100644
index 8a88ab051a6e44296e9d2b58e86ce25d4e418843..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Cisco Packet Tracer 6.0.1 For Windows (no Tutorials) Download.md	
+++ /dev/null
@@ -1,56 +0,0 @@
-<h2>Cisco Packet Tracer 6.0.1 for Windows (no tutorials) download</h2><br /><p><b><b>Download File</b> &#9881;&#9881;&#9881; <a href="https://urloso.com/2uyREI">https://urloso.com/2uyREI</a></b></p><br /><br />
-<br />
-Google Drive for Windows help page
-
-Google Drive for Mac help page
-
-Google Drive for Android help page
-
-Google Drive for iOS help page
-
-A:
-
-With version 2.0.5.2 of the library, the problem was fixed: 
-
-Eric Stein, co-founder and COO of Ink Tank Studios.
-
-As president of Ink Tank Studios, Eric Stein is responsible for all aspects of the company’s business, marketing, financing and technology. Eric co-founded Ink Tank in 2003 with five co-founders. He is an MBA graduate from UCLA and a former M&A and sales professional.
-
-Prior to the establishment of Ink Tank, Eric worked in the technology and media industry for 18 years. He spent the early part of his career at Red Dog Media, a market research and strategy firm based in New York, NY. He then moved into the entertainment industry as VP of Communications at Sequential. At Sequential, Eric was involved in several strategic projects, including the launch of the Fox Reality Channel. He also served as President and COO of Pappas Bros. Records.
-
-Eric currently lives in the Los Angeles area with his wife Tara and their two children..Text
-
-		} else 
-
-			buf.WriteRune(bom)
-
-		
-
-	}
-
-	return buf.String()
-
-}
-
-// isValidUTF8 reports whether s is a valid UTF-8.
-
-func isValidUTF8(s string) bool {
-
-	if len(s) == 0 {
-
-		return false
-
-	if len(s) > 4 && s[0] == '\xFE' && s[1] == '\xFF' && (s[2] == '\xBA' || s[2] == '\xBE') {
-
-		return true
-
-	return utf8.ValidString(s)
-
-Q:
-
-Wordpress - wp_mail() getting "Parse error: syntax error, unexpected '['"
-
-I was trying to send an email using wp_mail() function in a wordpress page, which was going very well until I reached the line mail($email, $email_subject, $email_message, $headers);. This line gives 4fefd39f24<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/bioriAsaeru/text-to-voice/Explore Numerical Methods That Work Pdf Download A Book on Modern Numerical Algorithms.md b/spaces/bioriAsaeru/text-to-voice/Explore Numerical Methods That Work Pdf Download A Book on Modern Numerical Algorithms.md
deleted file mode 100644
index ade6e914b3d01e7646cb8a480cf73051a3f3e131..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Explore Numerical Methods That Work Pdf Download A Book on Modern Numerical Algorithms.md	
+++ /dev/null
@@ -1,14 +0,0 @@
-
-<p>This book entitled Numerical Methods with Applications is written primarily for engineering and science undergraduates taking a course in Numerical Methods. The textbook offers a unique treatise to numerical methods which is based on a holistic approach and short chapters. This book is a product of many years of work on educational projects funded since 2002 by the National Science Foundation. Since our belief continues to embrace open and uncomplicated dissemination, individual chapters of the book in pdf form are always available free of charge.</p>
-<p>Textbooks used in recent years include:<ul><li>Arieh Iserles<br>A First Course in the Numerical Analysis of DifferentialEquations (Second Edition)<br>Cambridge University Press, New York, 2009ISBN: 978-0-521-73490-5 paperback</li><li>Kendall Atkinson<br>An Introduction to Numerical Analysis (Second Edition)<br>ISBN: 0-471-62489-6</li><li> W. Layton and M. Sussman, <i>Numerical LinearAlgebra</i>. This book is available as a free pdf download fromLulu.com.</ul>These are excellents texts that you may be able to borrow fromanother student.The labs are conducted using Matlab, a program producedby The MathWorks. The Matlab language is, in fact, an object-orientedprogramming language with an extensive library of mathematical andscientific function calls entirely built-in. A full-featuredstudent version of Matlab with some toolboxes is available for about $100as well as a version of Matlab alone for about $50.Pitt also offers a complete student version of Matlab including toolboxesavailable for free for studentsto download and install on their personal computers.</p>
-<h2>Numerical Methods That Work Pdf Download</h2><br /><p><b><b>Download Zip</b> === <a href="https://urloso.com/2uyRL7">https://urloso.com/2uyRL7</a></b></p><br /><br />
-<p>I will grade each lab either "A+", "A", "B", "C", "D" or 0.These letter grades can be described in the following manner:<ul><li> "A+" means "excellent": all exercises were completed correctly.</li><li> "A" means that all exercises were attempted and are largely correct.</li><li> "B" means that all exercises were attempted but there are someserious errors.</li><li> "C" means that not all exercises were attempted or the submission isotherwise not complete.</li><li> "D" means that there is almost no correct work submitted.</li><li> 0 means that the lab work was not submitted.</li></ul>At the endof the course, I will use these grades to provide a laboratory grade toProf. Neilan, who will use it for approximately 30% of your overall grade. Since omittedlabs count as zero, they will seriously impact your grade, so a latesubmission is greatly preferred over skipping a lab.</p>
-<p>If you are unable to complete a lab by its due date, youmay take additional time to complete the lab, <b>providedyou attend each lab session until you have completed and submittedthe work.</b> In that case, 2% will be deducted from that lab's gradefor the first week it is late (total of 3%), 3% for the second week(total of 6%), <i>etc.</i> <b>If you do not attend each lab session untilyou submit your work, you will be given a grade of zero for that lab.</b>Attending lab sessions offers the opportunity to resolve any questionsyou might have.</p>
-<p>Some comments are presented on the finite element analysis of the time dependent effects that develop when a tunnel is driven in a rock mass characterized by a viscous behaviour. First, the so called swelling and squeezing phenomena are described considering in particular rocks containing clay minerals. Subsequently the discussion is focused on the squeezing behaviour, i.e. on the time dependent increase of the shear deformation which develops with minor volume changes. Some linear and non-linear viscous constitutive laws are discussed, as well as their use in the solution of boundary value problems. Finally, the effects taking place around tunnels driven into squeezing rocks are illustrated through some numerical analyses based on these constitutive models.</p>
-<p><strong>Description</strong>:<br />This book is written for engineering undergraduates taking a course in numerical methods. The textbook offers a treatise to numerical methods which is based on a holistic approach and short chapters. It includes examples of real-life applications, supplemental material on differential and integral calculus, website with extra examples, PowerPoint presentations, worksheets in MATLAB, MATHEMATICA, Maple and MathCAD, etc.</p>
-<p>An increasing number of power electronic devices and new smart-grid technologies are used to ensure a safe, reliable, and high-quality operation of the power grid. However, the effectiveness of these control devices and technologies depends largely on the accuracy of the model, the advancement of control methods, and the numerical optimization of parameters. Therefore, this special issue is focused on recent advances in modeling, numerical analysis, control, and optimization of smart grids with special emphasis on the mathematical problems encountered at any stage of power grid operation, which will be particularly significant.</p>
-<p>Although much effort has been made on smart-grid research with a number of influential results obtained, there are still many challenging problems to be solved. Nowadays, advanced mathematical and numerical methods for the control and optimization for smart grids have become a popular research topic with the increase in complexity of the power grid.</p>
-<p>Sample computer programs are used extensively in the book to illustrate the programming concepts. You will need Microsoft Visual Studio 2019 or higher to work with the computer programs discussed in the book. Visual Studio Community 2019 edition is available for free, though I would recommend that you get the Professional or Enterprise edition that have desirable features not available with the Community edition.</p>
-<p></p> aaccfb2cb3<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/birsardar/stable-diffusion-mat-outpainting-primer/outpainting_example2.py b/spaces/birsardar/stable-diffusion-mat-outpainting-primer/outpainting_example2.py
deleted file mode 100644
index febe614ee3ba2cf19b14733ac844e19ac8bc6c64..0000000000000000000000000000000000000000
--- a/spaces/birsardar/stable-diffusion-mat-outpainting-primer/outpainting_example2.py
+++ /dev/null
@@ -1,197 +0,0 @@
-# %%
-# an example script of how to do outpainting with diffusers img2img pipeline
-# should be compatible with any stable diffusion model
-# (only tested with runwayml/stable-diffusion-v1-5)
-
-from typing import Callable, List, Optional, Union
-from PIL import Image
-import PIL
-import numpy as np
-import torch
-
-from diffusers import StableDiffusionImg2ImgPipeline
-from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
-from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img import preprocess
-
-pipe = StableDiffusionImg2ImgPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    revision="fp16",
-    torch_dtype=torch.float16,
-)
-
-pipe.set_use_memory_efficient_attention_xformers(True)
-pipe.to("cuda")
-# %%
-# load the image, extract the mask
-rgba = Image.open('primed_image_with_alpha_channel.png')
-mask_full = np.array(rgba)[:, :, 3] == 0
-rgb = rgba.convert('RGB')
-# %%
-
-# resize/convert the mask to the right size
-# for 512x512, the mask should be 1x4x64x64
-hw = np.array(mask_full.shape)
-h, w = (hw - hw % 32) // 8
-mask_image = Image.fromarray(mask_full).resize((w, h), Image.NEAREST)
-mask = (np.array(mask_image) == 0)[None, None]
-mask = np.concatenate([mask]*4, axis=1)
-mask = torch.from_numpy(mask).to('cuda')
-mask.shape
-
-# %%
-
-
-@torch.no_grad()
-def outpaint(
-    self: StableDiffusionImg2ImgPipeline,
-    prompt: Union[str, List[str]] = None,
-    image: Union[torch.FloatTensor, PIL.Image.Image] = None,
-    strength: float = 0.8,
-    num_inference_steps: Optional[int] = 50,
-    guidance_scale: Optional[float] = 7.5,
-    negative_prompt: Optional[Union[str, List[str]]] = None,
-    num_images_per_prompt: Optional[int] = 1,
-    eta: Optional[float] = 0.0,
-    generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-    prompt_embeds: Optional[torch.FloatTensor] = None,
-    negative_prompt_embeds: Optional[torch.FloatTensor] = None,
-    output_type: Optional[str] = "pil",
-    return_dict: bool = True,
-    callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-    callback_steps: Optional[int] = 1,
-    **kwargs,
-):
-    r"""
-    copy of the original img2img pipeline's __call__()
-    https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_img2img.py
-
-    Changes are marked with <EDIT> and </EDIT>
-    """
-    # message = "Please use `image` instead of `init_image`."
-    # init_image = deprecate("init_image", "0.14.0", message, take_from=kwargs)
-    # image = init_image or image
-
-    # 1. Check inputs. Raise error if not correct
-    self.check_inputs(prompt, strength, callback_steps,
-                      negative_prompt, prompt_embeds, negative_prompt_embeds)
-
-    # 2. Define call parameters
-    if prompt is not None and isinstance(prompt, str):
-        batch_size = 1
-    elif prompt is not None and isinstance(prompt, list):
-        batch_size = len(prompt)
-    else:
-        batch_size = prompt_embeds.shape[0]
-    device = self._execution_device
-    # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-    # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-    # corresponds to doing no classifier free guidance.
-    do_classifier_free_guidance = guidance_scale > 1.0
-
-    # 3. Encode input prompt
-    prompt_embeds = self._encode_prompt(
-        prompt,
-        device,
-        num_images_per_prompt,
-        do_classifier_free_guidance,
-        negative_prompt,
-        prompt_embeds=prompt_embeds,
-        negative_prompt_embeds=negative_prompt_embeds,
-    )
-
-    # 4. Preprocess image
-    image = preprocess(image)
-
-    # 5. set timesteps
-    self.scheduler.set_timesteps(num_inference_steps, device=device)
-    timesteps, num_inference_steps = self.get_timesteps(
-        num_inference_steps, strength, device)
-    latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)
-
-    # 6. Prepare latent variables
-    latents = self.prepare_latents(
-        image, latent_timestep, batch_size, num_images_per_prompt, prompt_embeds.dtype, device, generator
-    )
-
-    # <EDIT>
-    # store the encoded version of the original image to overwrite
-    # what the UNET generates "underneath" our image on each step
-    encoded_original = (self.vae.config.scaling_factor *
-                  self.vae.encode(
-                      image.to(latents.device, latents.dtype)
-                  ).latent_dist.mean)
-    # </EDIT>
-
-    # 7. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
-    extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-
-    # 8. Denoising loop
-    num_warmup_steps = len(timesteps) - \
-        num_inference_steps * self.scheduler.order
-    with self.progress_bar(total=num_inference_steps) as progress_bar:
-        for i, t in enumerate(timesteps):
-            # expand the latents if we are doing classifier free guidance
-            latent_model_input = torch.cat(
-                [latents] * 2) if do_classifier_free_guidance else latents
-            latent_model_input = self.scheduler.scale_model_input(
-                latent_model_input, t)
-
-            # predict the noise residual
-            noise_pred = self.unet(latent_model_input, t,
-                                   encoder_hidden_states=prompt_embeds).sample
-
-            # perform guidance
-            if do_classifier_free_guidance:
-                noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-                noise_pred = noise_pred_uncond + guidance_scale * \
-                    (noise_pred_text - noise_pred_uncond)
-
-            # compute the previous noisy sample x_t -> x_t-1
-            latents = self.scheduler.step(
-                noise_pred, t, latents, **extra_step_kwargs).prev_sample
-
-            # <EDIT> paste unmasked regions from the original image
-            noise = torch.randn(
-                encoded_original.shape, generator=generator, device=device)
-            noised_encoded_original = self.scheduler.add_noise(
-                encoded_original, noise, t).to(noise_pred.device, noise_pred.dtype)
-            latents[mask] = noised_encoded_original[mask]
-            # </EDIT>
-
-            # call the callback, if provided
-            if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
-                progress_bar.update()
-                if callback is not None and i % callback_steps == 0:
-                    callback(i, t, latents)
-
-    # 9. Post-processing
-    image = self.decode_latents(latents)
-
-    # 10. Run safety checker
-    image, has_nsfw_concept = self.run_safety_checker(
-        image, device, prompt_embeds.dtype)
-
-    # 11. Convert to PIL
-    if output_type == "pil":
-        image = self.numpy_to_pil(image)
-
-    if not return_dict:
-        return (image, has_nsfw_concept)
-
-    return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)
-
-
-# %%
-image = outpaint(
-    pipe,
-    image=rgb,
-    prompt="forest in the style of Tim Hildebrandt",
-    strength=0.5,
-    num_inference_steps=50,
-    guidance_scale=7.5,
-).images[0]
-image
-
-# %%
-# the vae does lossy encoding, we could get better quality if we pasted the original image into our result.
-# this may yield visible edges
diff --git a/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/grids/musicgen/musicgen_melody_32khz.py b/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/grids/musicgen/musicgen_melody_32khz.py
deleted file mode 100644
index b0d6710a23c117406e9724057a62eccab88ce907..0000000000000000000000000000000000000000
--- a/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/grids/musicgen/musicgen_melody_32khz.py
+++ /dev/null
@@ -1,65 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from ._explorers import LMExplorer
-from ...environment import AudioCraftEnvironment
-
-
-@LMExplorer
-def explorer(launcher):
-    partitions = AudioCraftEnvironment.get_slurm_partitions(['team', 'global'])
-    launcher.slurm_(gpus=32, partition=partitions)
-    launcher.bind_(solver='musicgen/musicgen_melody_32khz')
-    # replace this by the desired music dataset
-    launcher.bind_(dset='internal/music_400k_32khz')
-
-    fsdp = {'autocast': False, 'fsdp.use': True}
-    medium = {'model/lm/model_scale': 'medium'}
-    large = {'model/lm/model_scale': 'large'}
-
-    cfg_low = {'classifier_free_guidance.training_dropout': 0.2}
-    wd_low = {'conditioners.description.t5.word_dropout': 0.2}
-
-    adam = {'optim.optimizer': 'adamw', 'optim.lr': 1e-4}
-
-    cache_path = {'conditioners.self_wav.chroma_stem.cache_path':
-                  '/fsx-audio-craft-llm/jadecopet/experiments/audiocraft/caches/chroma_stem'}
-
-    # CACHE GENERATION JOBS
-    n_cache_gen_jobs = 4
-    gen_sub = launcher.slurm(gpus=1)
-    gen_sub.bind_(
-        cache_path, {
-            # the cache is always computed over the whole file, so duration doesn't matter here.
-            'dataset.segment_duration': 2.,
-            'dataset.batch_size': 8,
-            'dataset.train.permutation_on_files': True,  # try to not repeat files.
-            'optim.epochs': 10,
-            'model/lm/model_scale': 'xsmall',
-
-        })
-    with gen_sub.job_array():
-        for gen_job in range(n_cache_gen_jobs):
-            gen_sub({'dataset.train.shuffle_seed': gen_job})
-
-    # ACTUAL TRAINING JOBS.
-    launcher.bind_(fsdp)
-
-    launcher.slurm_(gpus=32).bind_(label='32gpus')
-    with launcher.job_array():
-        sub = launcher.bind()
-        sub()
-        sub(cache_path)
-
-    launcher.slurm_(gpus=64).bind_(label='64gpus')
-    with launcher.job_array():
-        sub = launcher.bind()
-        sub(medium, adam)
-
-    launcher.slurm_(gpus=96).bind_(label='96gpus')
-    with launcher.job_array():
-        sub = launcher.bind()
-        sub(large, cfg_low, wd_low, adam, {'optim.max_norm': 3})
diff --git a/spaces/brjathu/HMR2.0/vendor/detectron2/configs/common/models/panoptic_fpn.py b/spaces/brjathu/HMR2.0/vendor/detectron2/configs/common/models/panoptic_fpn.py
deleted file mode 100644
index 88f55d2ce9db62e61445d6a3700067d9d864ecae..0000000000000000000000000000000000000000
--- a/spaces/brjathu/HMR2.0/vendor/detectron2/configs/common/models/panoptic_fpn.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from detectron2.config import LazyCall as L
-from detectron2.layers import ShapeSpec
-from detectron2.modeling import PanopticFPN
-from detectron2.modeling.meta_arch.semantic_seg import SemSegFPNHead
-
-from .mask_rcnn_fpn import model
-
-model._target_ = PanopticFPN
-model.sem_seg_head = L(SemSegFPNHead)(
-    input_shape={
-        f: L(ShapeSpec)(stride=s, channels="${....backbone.out_channels}")
-        for f, s in zip(["p2", "p3", "p4", "p5"], [4, 8, 16, 32])
-    },
-    ignore_value=255,
-    num_classes=54,  # COCO stuff + 1
-    conv_dims=128,
-    common_stride=4,
-    loss_weight=0.5,
-    norm="GN",
-)
diff --git a/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/modeling/meta_arch/build.py b/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/modeling/meta_arch/build.py
deleted file mode 100644
index 3427215746c9a146bd902f22ea9b26d121c36b27..0000000000000000000000000000000000000000
--- a/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/modeling/meta_arch/build.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import torch
-
-from detectron2.utils.logger import _log_api_usage
-from detectron2.utils.registry import Registry
-
-META_ARCH_REGISTRY = Registry("META_ARCH")  # noqa F401 isort:skip
-META_ARCH_REGISTRY.__doc__ = """
-Registry for meta-architectures, i.e. the whole model.
-
-The registered object will be called with `obj(cfg)`
-and expected to return a `nn.Module` object.
-"""
-
-
-def build_model(cfg):
-    """
-    Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``.
-    Note that it does not load any weights from ``cfg``.
-    """
-    meta_arch = cfg.MODEL.META_ARCHITECTURE
-    model = META_ARCH_REGISTRY.get(meta_arch)(cfg)
-    model.to(torch.device(cfg.MODEL.DEVICE))
-    _log_api_usage("modeling.meta_arch." + meta_arch)
-    return model
diff --git a/spaces/brjathu/HMR2.0/vendor/detectron2/projects/DensePose/densepose/modeling/predictors/chart_confidence.py b/spaces/brjathu/HMR2.0/vendor/detectron2/projects/DensePose/densepose/modeling/predictors/chart_confidence.py
deleted file mode 100644
index 0c0099952f3e675e42aa7d3b6d35065fdaf43dbb..0000000000000000000000000000000000000000
--- a/spaces/brjathu/HMR2.0/vendor/detectron2/projects/DensePose/densepose/modeling/predictors/chart_confidence.py
+++ /dev/null
@@ -1,174 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-from typing import Any
-import torch
-from torch.nn import functional as F
-
-from detectron2.config import CfgNode
-from detectron2.layers import ConvTranspose2d
-
-from ...structures import decorate_predictor_output_class_with_confidences
-from ..confidence import DensePoseConfidenceModelConfig, DensePoseUVConfidenceType
-from ..utils import initialize_module_params
-
-
-class DensePoseChartConfidencePredictorMixin:
-    """
-    Predictor contains the last layers of a DensePose model that take DensePose head
-    outputs as an input and produce model outputs. Confidence predictor mixin is used
-    to generate confidences for segmentation and UV tensors estimated by some
-    base predictor. Several assumptions need to hold for the base predictor:
-    1) the `forward` method must return SIUV tuple as the first result (
-        S = coarse segmentation, I = fine segmentation, U and V are intrinsic
-        chart coordinates)
-    2) `interp2d` method must be defined to perform bilinear interpolation;
-        the same method is typically used for SIUV and confidences
-    Confidence predictor mixin provides confidence estimates, as described in:
-        N. Neverova et al., Correlated Uncertainty for Learning Dense Correspondences
-            from Noisy Labels, NeurIPS 2019
-        A. Sanakoyeu et al., Transferring Dense Pose to Proximal Animal Classes, CVPR 2020
-    """
-
-    def __init__(self, cfg: CfgNode, input_channels: int):
-        """
-        Initialize confidence predictor using configuration options.
-
-        Args:
-            cfg (CfgNode): configuration options
-            input_channels (int): number of input channels
-        """
-        # we rely on base predictor to call nn.Module.__init__
-        super().__init__(cfg, input_channels)  # pyre-ignore[19]
-        self.confidence_model_cfg = DensePoseConfidenceModelConfig.from_cfg(cfg)
-        self._initialize_confidence_estimation_layers(cfg, input_channels)
-        self._registry = {}
-        initialize_module_params(self)  # pyre-ignore[6]
-
-    def _initialize_confidence_estimation_layers(self, cfg: CfgNode, dim_in: int):
-        """
-        Initialize confidence estimation layers based on configuration options
-
-        Args:
-            cfg (CfgNode): configuration options
-            dim_in (int): number of input channels
-        """
-        dim_out_patches = cfg.MODEL.ROI_DENSEPOSE_HEAD.NUM_PATCHES + 1
-        kernel_size = cfg.MODEL.ROI_DENSEPOSE_HEAD.DECONV_KERNEL
-        if self.confidence_model_cfg.uv_confidence.enabled:
-            if self.confidence_model_cfg.uv_confidence.type == DensePoseUVConfidenceType.IID_ISO:
-                self.sigma_2_lowres = ConvTranspose2d(  # pyre-ignore[16]
-                    dim_in, dim_out_patches, kernel_size, stride=2, padding=int(kernel_size / 2 - 1)
-                )
-            elif (
-                self.confidence_model_cfg.uv_confidence.type
-                == DensePoseUVConfidenceType.INDEP_ANISO
-            ):
-                self.sigma_2_lowres = ConvTranspose2d(
-                    dim_in, dim_out_patches, kernel_size, stride=2, padding=int(kernel_size / 2 - 1)
-                )
-                self.kappa_u_lowres = ConvTranspose2d(  # pyre-ignore[16]
-                    dim_in, dim_out_patches, kernel_size, stride=2, padding=int(kernel_size / 2 - 1)
-                )
-                self.kappa_v_lowres = ConvTranspose2d(  # pyre-ignore[16]
-                    dim_in, dim_out_patches, kernel_size, stride=2, padding=int(kernel_size / 2 - 1)
-                )
-            else:
-                raise ValueError(
-                    f"Unknown confidence model type: "
-                    f"{self.confidence_model_cfg.confidence_model_type}"
-                )
-        if self.confidence_model_cfg.segm_confidence.enabled:
-            self.fine_segm_confidence_lowres = ConvTranspose2d(  # pyre-ignore[16]
-                dim_in, 1, kernel_size, stride=2, padding=int(kernel_size / 2 - 1)
-            )
-            self.coarse_segm_confidence_lowres = ConvTranspose2d(  # pyre-ignore[16]
-                dim_in, 1, kernel_size, stride=2, padding=int(kernel_size / 2 - 1)
-            )
-
-    def forward(self, head_outputs: torch.Tensor):
-        """
-        Perform forward operation on head outputs used as inputs for the predictor.
-        Calls forward method from the base predictor and uses its outputs to compute
-        confidences.
-
-        Args:
-            head_outputs (Tensor): head outputs used as predictor inputs
-        Return:
-            An instance of outputs with confidences,
-            see `decorate_predictor_output_class_with_confidences`
-        """
-        # assuming base class returns SIUV estimates in its first result
-        base_predictor_outputs = super().forward(head_outputs)  # pyre-ignore[16]
-
-        # create output instance by extending base predictor outputs:
-        output = self._create_output_instance(base_predictor_outputs)
-
-        if self.confidence_model_cfg.uv_confidence.enabled:
-            if self.confidence_model_cfg.uv_confidence.type == DensePoseUVConfidenceType.IID_ISO:
-                # assuming base class defines interp2d method for bilinear interpolation
-                output.sigma_2 = self.interp2d(self.sigma_2_lowres(head_outputs))  # pyre-ignore[16]
-            elif (
-                self.confidence_model_cfg.uv_confidence.type
-                == DensePoseUVConfidenceType.INDEP_ANISO
-            ):
-                # assuming base class defines interp2d method for bilinear interpolation
-                output.sigma_2 = self.interp2d(self.sigma_2_lowres(head_outputs))
-                output.kappa_u = self.interp2d(self.kappa_u_lowres(head_outputs))  # pyre-ignore[16]
-                output.kappa_v = self.interp2d(self.kappa_v_lowres(head_outputs))  # pyre-ignore[16]
-            else:
-                raise ValueError(
-                    f"Unknown confidence model type: "
-                    f"{self.confidence_model_cfg.confidence_model_type}"
-                )
-        if self.confidence_model_cfg.segm_confidence.enabled:
-            # base predictor outputs are assumed to have `fine_segm` and `coarse_segm` attributes
-            # base predictor is assumed to define `interp2d` method for bilinear interpolation
-            output.fine_segm_confidence = (
-                F.softplus(
-                    self.interp2d(self.fine_segm_confidence_lowres(head_outputs))  # pyre-ignore[16]
-                )
-                + self.confidence_model_cfg.segm_confidence.epsilon
-            )
-            output.fine_segm = base_predictor_outputs.fine_segm * torch.repeat_interleave(
-                output.fine_segm_confidence, base_predictor_outputs.fine_segm.shape[1], dim=1
-            )
-            output.coarse_segm_confidence = (
-                F.softplus(
-                    self.interp2d(
-                        self.coarse_segm_confidence_lowres(head_outputs)  # pyre-ignore[16]
-                    )
-                )
-                + self.confidence_model_cfg.segm_confidence.epsilon
-            )
-            output.coarse_segm = base_predictor_outputs.coarse_segm * torch.repeat_interleave(
-                output.coarse_segm_confidence, base_predictor_outputs.coarse_segm.shape[1], dim=1
-            )
-
-        return output
-
-    def _create_output_instance(self, base_predictor_outputs: Any):
-        """
-        Create an instance of predictor outputs by copying the outputs from the
-        base predictor and initializing confidence
-
-        Args:
-            base_predictor_outputs: an instance of base predictor outputs
-                (the outputs type is assumed to be a dataclass)
-        Return:
-           An instance of outputs with confidences
-        """
-        PredictorOutput = decorate_predictor_output_class_with_confidences(
-            type(base_predictor_outputs)  # pyre-ignore[6]
-        )
-        # base_predictor_outputs is assumed to be a dataclass
-        # reassign all the fields from base_predictor_outputs (no deep copy!), add new fields
-        output = PredictorOutput(
-            **base_predictor_outputs.__dict__,
-            coarse_segm_confidence=None,
-            fine_segm_confidence=None,
-            sigma_1=None,
-            sigma_2=None,
-            kappa_u=None,
-            kappa_v=None,
-        )
-        return output
diff --git a/spaces/brjathu/HMR2.0/vendor/detectron2/tests/config/dir1/load_rel.py b/spaces/brjathu/HMR2.0/vendor/detectron2/tests/config/dir1/load_rel.py
deleted file mode 100644
index 22d10db7fe28ad66819aeb8e991f129301095ea1..0000000000000000000000000000000000000000
--- a/spaces/brjathu/HMR2.0/vendor/detectron2/tests/config/dir1/load_rel.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# test that load_rel can work
-from detectron2.config import LazyConfig
-
-x = LazyConfig.load_rel("dir1_a.py", "dir1a_dict")
-assert x["a"] == 1
diff --git a/spaces/camenduru-com/VITS-Umamusume-voice-synthesizer/data_utils.py b/spaces/camenduru-com/VITS-Umamusume-voice-synthesizer/data_utils.py
deleted file mode 100644
index e9246c6c8f2ff3c37a7f8529ea1593c7f80f887e..0000000000000000000000000000000000000000
--- a/spaces/camenduru-com/VITS-Umamusume-voice-synthesizer/data_utils.py
+++ /dev/null
@@ -1,393 +0,0 @@
-import time
-import os
-import random
-import numpy as np
-import torch
-import torch.utils.data
-
-import commons 
-from mel_processing import spectrogram_torch
-from utils import load_wav_to_torch, load_filepaths_and_text
-from text import text_to_sequence, cleaned_text_to_sequence
-
-
-class TextAudioLoader(torch.utils.data.Dataset):
-    """
-        1) loads audio, text pairs
-        2) normalizes text and converts them to sequences of integers
-        3) computes spectrograms from audio files.
-    """
-    def __init__(self, audiopaths_and_text, hparams):
-        self.audiopaths_and_text = load_filepaths_and_text(audiopaths_and_text)
-        self.text_cleaners  = hparams.text_cleaners
-        self.max_wav_value  = hparams.max_wav_value
-        self.sampling_rate  = hparams.sampling_rate
-        self.filter_length  = hparams.filter_length 
-        self.hop_length     = hparams.hop_length 
-        self.win_length     = hparams.win_length
-        self.sampling_rate  = hparams.sampling_rate 
-
-        self.cleaned_text = getattr(hparams, "cleaned_text", False)
-
-        self.add_blank = hparams.add_blank
-        self.min_text_len = getattr(hparams, "min_text_len", 1)
-        self.max_text_len = getattr(hparams, "max_text_len", 190)
-
-        random.seed(1234)
-        random.shuffle(self.audiopaths_and_text)
-        self._filter()
-
-
-    def _filter(self):
-        """
-        Filter text & store spec lengths
-        """
-        # Store spectrogram lengths for Bucketing
-        # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2)
-        # spec_length = wav_length // hop_length
-
-        audiopaths_and_text_new = []
-        lengths = []
-        for audiopath, text in self.audiopaths_and_text:
-            if self.min_text_len <= len(text) and len(text) <= self.max_text_len:
-                audiopaths_and_text_new.append([audiopath, text])
-                lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length))
-        self.audiopaths_and_text = audiopaths_and_text_new
-        self.lengths = lengths
-
-    def get_audio_text_pair(self, audiopath_and_text):
-        # separate filename and text
-        audiopath, text = audiopath_and_text[0], audiopath_and_text[1]
-        text = self.get_text(text)
-        spec, wav = self.get_audio(audiopath)
-        return (text, spec, wav)
-
-    def get_audio(self, filename):
-        audio, sampling_rate = load_wav_to_torch(filename)
-        if sampling_rate != self.sampling_rate:
-            raise ValueError("{} {} SR doesn't match target {} SR".format(
-                sampling_rate, self.sampling_rate))
-        audio_norm = audio / self.max_wav_value
-        audio_norm = audio_norm.unsqueeze(0)
-        spec_filename = filename.replace(".wav", ".spec.pt")
-        if os.path.exists(spec_filename):
-            spec = torch.load(spec_filename)
-        else:
-            spec = spectrogram_torch(audio_norm, self.filter_length,
-                self.sampling_rate, self.hop_length, self.win_length,
-                center=False)
-            spec = torch.squeeze(spec, 0)
-            torch.save(spec, spec_filename)
-        return spec, audio_norm
-
-    def get_text(self, text):
-        if self.cleaned_text:
-            text_norm = cleaned_text_to_sequence(text)
-        else:
-            text_norm = text_to_sequence(text, self.text_cleaners)
-        if self.add_blank:
-            text_norm = commons.intersperse(text_norm, 0)
-        text_norm = torch.LongTensor(text_norm)
-        return text_norm
-
-    def __getitem__(self, index):
-        return self.get_audio_text_pair(self.audiopaths_and_text[index])
-
-    def __len__(self):
-        return len(self.audiopaths_and_text)
-
-
-class TextAudioCollate():
-    """ Zero-pads model inputs and targets
-    """
-    def __init__(self, return_ids=False):
-        self.return_ids = return_ids
-
-    def __call__(self, batch):
-        """Collate's training batch from normalized text and aduio
-        PARAMS
-        ------
-        batch: [text_normalized, spec_normalized, wav_normalized]
-        """
-        # Right zero-pad all one-hot text sequences to max input length
-        _, ids_sorted_decreasing = torch.sort(
-            torch.LongTensor([x[1].size(1) for x in batch]),
-            dim=0, descending=True)
-
-        max_text_len = max([len(x[0]) for x in batch])
-        max_spec_len = max([x[1].size(1) for x in batch])
-        max_wav_len = max([x[2].size(1) for x in batch])
-
-        text_lengths = torch.LongTensor(len(batch))
-        spec_lengths = torch.LongTensor(len(batch))
-        wav_lengths = torch.LongTensor(len(batch))
-
-        text_padded = torch.LongTensor(len(batch), max_text_len)
-        spec_padded = torch.FloatTensor(len(batch), batch[0][1].size(0), max_spec_len)
-        wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
-        text_padded.zero_()
-        spec_padded.zero_()
-        wav_padded.zero_()
-        for i in range(len(ids_sorted_decreasing)):
-            row = batch[ids_sorted_decreasing[i]]
-
-            text = row[0]
-            text_padded[i, :text.size(0)] = text
-            text_lengths[i] = text.size(0)
-
-            spec = row[1]
-            spec_padded[i, :, :spec.size(1)] = spec
-            spec_lengths[i] = spec.size(1)
-
-            wav = row[2]
-            wav_padded[i, :, :wav.size(1)] = wav
-            wav_lengths[i] = wav.size(1)
-
-        if self.return_ids:
-            return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, ids_sorted_decreasing
-        return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths
-
-
-"""Multi speaker version"""
-class TextAudioSpeakerLoader(torch.utils.data.Dataset):
-    """
-        1) loads audio, speaker_id, text pairs
-        2) normalizes text and converts them to sequences of integers
-        3) computes spectrograms from audio files.
-    """
-    def __init__(self, audiopaths_sid_text, hparams):
-        self.audiopaths_sid_text = load_filepaths_and_text(audiopaths_sid_text)
-        self.text_cleaners = hparams.text_cleaners
-        self.max_wav_value = hparams.max_wav_value
-        self.sampling_rate = hparams.sampling_rate
-        self.filter_length  = hparams.filter_length
-        self.hop_length     = hparams.hop_length
-        self.win_length     = hparams.win_length
-        self.sampling_rate  = hparams.sampling_rate
-
-        self.cleaned_text = getattr(hparams, "cleaned_text", False)
-
-        self.add_blank = hparams.add_blank
-        self.min_text_len = getattr(hparams, "min_text_len", 1)
-        self.max_text_len = getattr(hparams, "max_text_len", 190)
-
-        random.seed(1234)
-        random.shuffle(self.audiopaths_sid_text)
-        self._filter()
-
-    def _filter(self):
-        """
-        Filter text & store spec lengths
-        """
-        # Store spectrogram lengths for Bucketing
-        # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2)
-        # spec_length = wav_length // hop_length
-
-        audiopaths_sid_text_new = []
-        lengths = []
-        for audiopath, sid, text in self.audiopaths_sid_text:
-            audiopath = "E:/uma_voice/" + audiopath
-            if self.min_text_len <= len(text) and len(text) <= self.max_text_len:
-                audiopaths_sid_text_new.append([audiopath, sid, text])
-                lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length))
-        self.audiopaths_sid_text = audiopaths_sid_text_new
-        self.lengths = lengths
-
-    def get_audio_text_speaker_pair(self, audiopath_sid_text):
-        # separate filename, speaker_id and text
-        audiopath, sid, text = audiopath_sid_text[0], audiopath_sid_text[1], audiopath_sid_text[2]
-        text = self.get_text(text)
-        spec, wav = self.get_audio(audiopath)
-        sid = self.get_sid(sid)
-        return (text, spec, wav, sid)
-
-    def get_audio(self, filename):
-        audio, sampling_rate = load_wav_to_torch(filename)
-        if sampling_rate != self.sampling_rate:
-            raise ValueError("{} {} SR doesn't match target {} SR".format(
-                sampling_rate, self.sampling_rate))
-        audio_norm = audio / self.max_wav_value
-        audio_norm = audio_norm.unsqueeze(0)
-        spec_filename = filename.replace(".wav", ".spec.pt")
-        if os.path.exists(spec_filename):
-            spec = torch.load(spec_filename)
-        else:
-            spec = spectrogram_torch(audio_norm, self.filter_length,
-                self.sampling_rate, self.hop_length, self.win_length,
-                center=False)
-            spec = torch.squeeze(spec, 0)
-            torch.save(spec, spec_filename)
-        return spec, audio_norm
-
-    def get_text(self, text):
-        if self.cleaned_text:
-            text_norm = cleaned_text_to_sequence(text)
-        else:
-            text_norm = text_to_sequence(text, self.text_cleaners)
-        if self.add_blank:
-            text_norm = commons.intersperse(text_norm, 0)
-        text_norm = torch.LongTensor(text_norm)
-        return text_norm
-
-    def get_sid(self, sid):
-        sid = torch.LongTensor([int(sid)])
-        return sid
-
-    def __getitem__(self, index):
-        return self.get_audio_text_speaker_pair(self.audiopaths_sid_text[index])
-
-    def __len__(self):
-        return len(self.audiopaths_sid_text)
-
-
-class TextAudioSpeakerCollate():
-    """ Zero-pads model inputs and targets
-    """
-    def __init__(self, return_ids=False):
-        self.return_ids = return_ids
-
-    def __call__(self, batch):
-        """Collate's training batch from normalized text, audio and speaker identities
-        PARAMS
-        ------
-        batch: [text_normalized, spec_normalized, wav_normalized, sid]
-        """
-        # Right zero-pad all one-hot text sequences to max input length
-        _, ids_sorted_decreasing = torch.sort(
-            torch.LongTensor([x[1].size(1) for x in batch]),
-            dim=0, descending=True)
-
-        max_text_len = max([len(x[0]) for x in batch])
-        max_spec_len = max([x[1].size(1) for x in batch])
-        max_wav_len = max([x[2].size(1) for x in batch])
-
-        text_lengths = torch.LongTensor(len(batch))
-        spec_lengths = torch.LongTensor(len(batch))
-        wav_lengths = torch.LongTensor(len(batch))
-        sid = torch.LongTensor(len(batch))
-
-        text_padded = torch.LongTensor(len(batch), max_text_len)
-        spec_padded = torch.FloatTensor(len(batch), batch[0][1].size(0), max_spec_len)
-        wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
-        text_padded.zero_()
-        spec_padded.zero_()
-        wav_padded.zero_()
-        for i in range(len(ids_sorted_decreasing)):
-            row = batch[ids_sorted_decreasing[i]]
-
-            text = row[0]
-            text_padded[i, :text.size(0)] = text
-            text_lengths[i] = text.size(0)
-
-            spec = row[1]
-            spec_padded[i, :, :spec.size(1)] = spec
-            spec_lengths[i] = spec.size(1)
-
-            wav = row[2]
-            wav_padded[i, :, :wav.size(1)] = wav
-            wav_lengths[i] = wav.size(1)
-
-            sid[i] = row[3]
-
-        if self.return_ids:
-            return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, sid, ids_sorted_decreasing
-        return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, sid
-
-
-class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler):
-    """
-    Maintain similar input lengths in a batch.
-    Length groups are specified by boundaries.
-    Ex) boundaries = [b1, b2, b3] -> any batch is included either {x | b1 < length(x) <=b2} or {x | b2 < length(x) <= b3}.
-  
-    It removes samples which are not included in the boundaries.
-    Ex) boundaries = [b1, b2, b3] -> any x s.t. length(x) <= b1 or length(x) > b3 are discarded.
-    """
-    def __init__(self, dataset, batch_size, boundaries, num_replicas=None, rank=None, shuffle=True):
-        super().__init__(dataset, num_replicas=num_replicas, rank=rank, shuffle=shuffle)
-        self.lengths = dataset.lengths
-        self.batch_size = batch_size
-        self.boundaries = boundaries
-  
-        self.buckets, self.num_samples_per_bucket = self._create_buckets()
-        self.total_size = sum(self.num_samples_per_bucket)
-        self.num_samples = self.total_size // self.num_replicas
-  
-    def _create_buckets(self):
-        buckets = [[] for _ in range(len(self.boundaries) - 1)]
-        for i in range(len(self.lengths)):
-            length = self.lengths[i]
-            idx_bucket = self._bisect(length)
-            if idx_bucket != -1:
-                buckets[idx_bucket].append(i)
-  
-        for i in range(len(buckets) - 1, 0, -1):
-            if len(buckets[i]) == 0:
-                buckets.pop(i)
-                self.boundaries.pop(i+1)
-  
-        num_samples_per_bucket = []
-        for i in range(len(buckets)):
-            len_bucket = len(buckets[i])
-            total_batch_size = self.num_replicas * self.batch_size
-            rem = (total_batch_size - (len_bucket % total_batch_size)) % total_batch_size
-            num_samples_per_bucket.append(len_bucket + rem)
-        return buckets, num_samples_per_bucket
-  
-    def __iter__(self):
-      # deterministically shuffle based on epoch
-      g = torch.Generator()
-      g.manual_seed(self.epoch)
-  
-      indices = []
-      if self.shuffle:
-          for bucket in self.buckets:
-              indices.append(torch.randperm(len(bucket), generator=g).tolist())
-      else:
-          for bucket in self.buckets:
-              indices.append(list(range(len(bucket))))
-  
-      batches = []
-      for i in range(len(self.buckets)):
-          bucket = self.buckets[i]
-          len_bucket = len(bucket)
-          ids_bucket = indices[i]
-          num_samples_bucket = self.num_samples_per_bucket[i]
-  
-          # add extra samples to make it evenly divisible
-          rem = num_samples_bucket - len_bucket
-          ids_bucket = ids_bucket + ids_bucket * (rem // len_bucket) + ids_bucket[:(rem % len_bucket)]
-  
-          # subsample
-          ids_bucket = ids_bucket[self.rank::self.num_replicas]
-  
-          # batching
-          for j in range(len(ids_bucket) // self.batch_size):
-              batch = [bucket[idx] for idx in ids_bucket[j*self.batch_size:(j+1)*self.batch_size]]
-              batches.append(batch)
-  
-      if self.shuffle:
-          batch_ids = torch.randperm(len(batches), generator=g).tolist()
-          batches = [batches[i] for i in batch_ids]
-      self.batches = batches
-  
-      assert len(self.batches) * self.batch_size == self.num_samples
-      return iter(self.batches)
-  
-    def _bisect(self, x, lo=0, hi=None):
-      if hi is None:
-          hi = len(self.boundaries) - 1
-  
-      if hi > lo:
-          mid = (hi + lo) // 2
-          if self.boundaries[mid] < x and x <= self.boundaries[mid+1]:
-              return mid
-          elif x <= self.boundaries[mid]:
-              return self._bisect(x, lo, mid)
-          else:
-              return self._bisect(x, mid + 1, hi)
-      else:
-          return -1
-
-    def __len__(self):
-        return self.num_samples // self.batch_size
diff --git a/spaces/carlosabadia/face_detection/README.md b/spaces/carlosabadia/face_detection/README.md
deleted file mode 100644
index bfd1e546fea5d87a774d3bbc5d9a92040af98227..0000000000000000000000000000000000000000
--- a/spaces/carlosabadia/face_detection/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Face Detection
-emoji: 👤
-colorFrom: green
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.4.1
-app_file: app.py
-pinned: false
-license: mit
----
diff --git a/spaces/cccc-c/bingo/src/app/loading.css b/spaces/cccc-c/bingo/src/app/loading.css
deleted file mode 100644
index eaaab6a86a228334c4eca3c5368ae6f0f593d405..0000000000000000000000000000000000000000
--- a/spaces/cccc-c/bingo/src/app/loading.css
+++ /dev/null
@@ -1,68 +0,0 @@
-::-webkit-scrollbar {
-  width: 10px;
-  height: 10px;
-  display: none;
-}
-
-::-webkit-scrollbar-button:start:decrement,
-::-webkit-scrollbar-button:end:increment {
-  height: 30px;
-  background-color: transparent;
-}
-
-::-webkit-scrollbar-track-piece {
-  background-color: #3b3b3b;
-  -webkit-border-radius: 16px;
-}
-
-::-webkit-scrollbar-thumb:vertical {
-  height: 50px;
-  background-color: #666;
-  border: 1px solid #eee;
-  -webkit-border-radius: 6px;
-}
-
-/* loading start */
-.loading-spinner {
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  height: 100vh;
-  opacity: 1;
-  transition: opacity .8s ease-out;
-}
-
-.loading-spinner.hidden {
-  opacity: 0;
-}
-
-.loading-spinner>div {
-  width: 30px;
-  height: 30px;
-  background: linear-gradient(90deg, #2870EA 10.79%, #1B4AEF 87.08%);
-
-  border-radius: 100%;
-  display: inline-block;
-  animation: sk-bouncedelay 1.4s infinite ease-in-out both;
-}
-
-.loading-spinner .bounce1 {
-  animation-delay: -0.32s;
-}
-
-.loading-spinner .bounce2 {
-  animation-delay: -0.16s;
-}
-
-@keyframes sk-bouncedelay {
-
-  0%,
-  80%,
-  100% {
-    transform: scale(0);
-  }
-
-  40% {
-    transform: scale(1.0);
-  }
-}
diff --git a/spaces/ccds/vits_onnx/export/vits/inference_onnx.py b/spaces/ccds/vits_onnx/export/vits/inference_onnx.py
deleted file mode 100644
index 4da92d1c368c50b0de092f8a151a31303f8eac41..0000000000000000000000000000000000000000
--- a/spaces/ccds/vits_onnx/export/vits/inference_onnx.py
+++ /dev/null
@@ -1,148 +0,0 @@
-# Copyright (c) 2022, Yongqiang Li (yongqiangli@alumni.hust.edu.cn)
-#
-# 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 text import text_to_sequence
-import numpy as np
-from scipy.io import wavfile
-import torch
-import json
-import commons
-import utils
-import sys
-import pathlib
-
-try:
-    import onnxruntime as ort
-except ImportError:
-    print('Please install onnxruntime!')
-    sys.exit(1)
-
-
-def to_numpy(tensor: torch.Tensor):
-    return tensor.detach().cpu().numpy() if tensor.requires_grad \
-        else tensor.detach().numpy()
-
-
-def get_args():
-    parser = argparse.ArgumentParser(description='inference')
-    parser.add_argument('--onnx_model', required=True, help='onnx model')
-    parser.add_argument('--cfg', required=True, help='config file')
-    parser.add_argument('--outdir', default="onnx_output",
-                        help='ouput directory')
-    # parser.add_argument('--phone_table',
-    #                     required=True,
-    #                     help='input phone dict')
-    # parser.add_argument('--speaker_table', default=None, help='speaker table')
-    parser.add_argument('--test_file', required=True, help='test file')
-    args = parser.parse_args()
-    return args
-
-
-def get_symbols_from_json(path):
-    import os
-    assert os.path.isfile(path)
-    with open(path, 'r') as f:
-        data = json.load(f)
-    return data['symbols']
-
-
-def main():
-    args = get_args()
-    print(args)
-    if not pathlib.Path(args.outdir).exists():
-        pathlib.Path(args.outdir).mkdir(exist_ok=True, parents=True)
-    # phones =
-    symbols = get_symbols_from_json(args.cfg)
-    phone_dict = {
-        symbol: i for i, symbol in enumerate(symbols)
-    }
-
-    # speaker_dict = {}
-    # if args.speaker_table is not None:
-    #     with open(args.speaker_table) as p_f:
-    #         for line in p_f:
-    #             arr = line.strip().split()
-    #             assert len(arr) == 2
-    #             speaker_dict[arr[0]] = int(arr[1])
-    hps = utils.get_hparams_from_file(args.cfg)
-
-    ort_sess = ort.InferenceSession(args.onnx_model)
-
-    with open(args.test_file) as fin:
-        for line in fin:
-            arr = line.strip().split("|")
-            audio_path = arr[0]
-        
-            # TODO: 控制说话人编号
-            sid = 8
-            text = arr[1]
-            # else:
-            #     sid = speaker_dict[arr[1]]
-            #     text = arr[2]
-            seq = text_to_sequence(text, symbols=hps.symbols, cleaner_names=["japanese_cleaners2"]
-                                   )
-            if hps.data.add_blank:
-                seq = commons.intersperse(seq, 0)
-
-            # if hps.data.add_blank:
-            #     seq = commons.intersperse(seq, 0)
-            with torch.no_grad():
-                #         x = torch.LongTensor([seq])
-                #         x_len = torch.IntTensor([x.size(1)]).long()
-                #         sid = torch.LongTensor([sid]).long()
-                #         scales = torch.FloatTensor([0.667, 1.0, 1])
-                # # make triton dynamic shape happy
-                #         scales = scales.unsqueeze(0)
-
-                # use numpy to replace torch
-                x = np.array([seq], dtype=np.int64)
-                x_len = np.array([x.shape[1]], dtype=np.int64)
-                sid = np.array([sid], dtype=np.int64)
-                # noise(可用于控制感情等变化程度) lenth(可用于控制整体语速) noisew(控制音素发音长度变化程度)
-                # 参考 https://github.com/gbxh/genshinTTS
-                scales = np.array([0.667, 0.8, 1], dtype=np.float32)
-                # scales = scales[np.newaxis, :]
-                # scales.reshape(1, -1)
-                scales.resize(1, 3)
-
-                ort_inputs = {
-                    'input': x,
-                    'input_lengths': x_len,
-                    'scales': scales,
-                    'sid': sid
-                }
-
-                # ort_inputs = {
-                #     'input': to_numpy(x),
-                #     'input_lengths': to_numpy(x_len),
-                #     'scales': to_numpy(scales),
-                #     'sid': to_numpy(sid)
-                # }
-                import time
-                # start_time = time.time()
-                start_time = time.perf_counter()
-                audio = np.squeeze(ort_sess.run(None, ort_inputs))
-                audio *= 32767.0 / max(0.01, np.max(np.abs(audio))) * 0.6
-                audio = np.clip(audio, -32767.0, 32767.0)
-                end_time = time.perf_counter()
-                # end_time = time.time()
-                print("infer time cost: ", end_time - start_time, "s")
-
-                wavfile.write(args.outdir + "/" + audio_path.split("/")[-1],
-                              hps.data.sampling_rate, audio.astype(np.int16))
-
-
-if __name__ == '__main__':
-    main()
diff --git a/spaces/chendl/compositional_test/multimodal/Makefile b/spaces/chendl/compositional_test/multimodal/Makefile
deleted file mode 100644
index d5cc3840bce9ce0e5aebc435f63ffa5b534d4a8f..0000000000000000000000000000000000000000
--- a/spaces/chendl/compositional_test/multimodal/Makefile
+++ /dev/null
@@ -1,19 +0,0 @@
-install: ## [Local development] Upgrade pip, install requirements, install package.
-	python -m pip install -U pip
-	python -m pip install -e .
-
-install-dev: ## [Local development] Install test requirements
-	python -m pip install -r requirements-test.txt
-
-lint: ## [Local development] Run mypy, pylint and black
-	python -m mypy open_flamingo
-	python -m pylint open_flamingo
-	python -m black --check -l 120 open_flamingo
-
-black: ## [Local development] Auto-format python code using black
-	python -m black -l 120 .
-
-.PHONY: help
-
-help: # Run `make help` to get help on the make commands
-	@grep -E '^[0-9a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
\ No newline at end of file
diff --git a/spaces/chendl/compositional_test/transformers/examples/legacy/pytorch-lightning/lightning_base.py b/spaces/chendl/compositional_test/transformers/examples/legacy/pytorch-lightning/lightning_base.py
deleted file mode 100644
index f246ecab0dd01bceda5c612dad9b0679a9691a6a..0000000000000000000000000000000000000000
--- a/spaces/chendl/compositional_test/transformers/examples/legacy/pytorch-lightning/lightning_base.py
+++ /dev/null
@@ -1,393 +0,0 @@
-import argparse
-import logging
-import os
-from pathlib import Path
-from typing import Any, Dict
-
-import pytorch_lightning as pl
-from pytorch_lightning.utilities import rank_zero_info
-
-from transformers import (
-    AdamW,
-    AutoConfig,
-    AutoModel,
-    AutoModelForPreTraining,
-    AutoModelForQuestionAnswering,
-    AutoModelForSeq2SeqLM,
-    AutoModelForSequenceClassification,
-    AutoModelForTokenClassification,
-    AutoModelWithLMHead,
-    AutoTokenizer,
-    PretrainedConfig,
-    PreTrainedTokenizer,
-)
-from transformers.optimization import (
-    Adafactor,
-    get_cosine_schedule_with_warmup,
-    get_cosine_with_hard_restarts_schedule_with_warmup,
-    get_linear_schedule_with_warmup,
-    get_polynomial_decay_schedule_with_warmup,
-)
-from transformers.utils.versions import require_version
-
-
-logger = logging.getLogger(__name__)
-
-require_version("pytorch_lightning>=1.0.4")
-
-MODEL_MODES = {
-    "base": AutoModel,
-    "sequence-classification": AutoModelForSequenceClassification,
-    "question-answering": AutoModelForQuestionAnswering,
-    "pretraining": AutoModelForPreTraining,
-    "token-classification": AutoModelForTokenClassification,
-    "language-modeling": AutoModelWithLMHead,
-    "summarization": AutoModelForSeq2SeqLM,
-    "translation": AutoModelForSeq2SeqLM,
-}
-
-
-# update this and the import above to support new schedulers from transformers.optimization
-arg_to_scheduler = {
-    "linear": get_linear_schedule_with_warmup,
-    "cosine": get_cosine_schedule_with_warmup,
-    "cosine_w_restarts": get_cosine_with_hard_restarts_schedule_with_warmup,
-    "polynomial": get_polynomial_decay_schedule_with_warmup,
-    # '': get_constant_schedule,             # not supported for now
-    # '': get_constant_schedule_with_warmup, # not supported for now
-}
-arg_to_scheduler_choices = sorted(arg_to_scheduler.keys())
-arg_to_scheduler_metavar = "{" + ", ".join(arg_to_scheduler_choices) + "}"
-
-
-class BaseTransformer(pl.LightningModule):
-    def __init__(
-        self,
-        hparams: argparse.Namespace,
-        num_labels=None,
-        mode="base",
-        config=None,
-        tokenizer=None,
-        model=None,
-        **config_kwargs,
-    ):
-        """Initialize a model, tokenizer and config."""
-        super().__init__()
-        # TODO: move to self.save_hyperparameters()
-        # self.save_hyperparameters()
-        # can also expand arguments into trainer signature for easier reading
-
-        self.save_hyperparameters(hparams)
-        self.step_count = 0
-        self.output_dir = Path(self.hparams.output_dir)
-        cache_dir = self.hparams.cache_dir if self.hparams.cache_dir else None
-        if config is None:
-            self.config = AutoConfig.from_pretrained(
-                self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path,
-                **({"num_labels": num_labels} if num_labels is not None else {}),
-                cache_dir=cache_dir,
-                **config_kwargs,
-            )
-        else:
-            self.config: PretrainedConfig = config
-
-        extra_model_params = ("encoder_layerdrop", "decoder_layerdrop", "dropout", "attention_dropout")
-        for p in extra_model_params:
-            if getattr(self.hparams, p, None):
-                assert hasattr(self.config, p), f"model config doesn't have a `{p}` attribute"
-                setattr(self.config, p, getattr(self.hparams, p))
-
-        if tokenizer is None:
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path,
-                cache_dir=cache_dir,
-            )
-        else:
-            self.tokenizer: PreTrainedTokenizer = tokenizer
-        self.model_type = MODEL_MODES[mode]
-        if model is None:
-            self.model = self.model_type.from_pretrained(
-                self.hparams.model_name_or_path,
-                from_tf=bool(".ckpt" in self.hparams.model_name_or_path),
-                config=self.config,
-                cache_dir=cache_dir,
-            )
-        else:
-            self.model = model
-
-    def load_hf_checkpoint(self, *args, **kwargs):
-        self.model = self.model_type.from_pretrained(*args, **kwargs)
-
-    def get_lr_scheduler(self):
-        get_schedule_func = arg_to_scheduler[self.hparams.lr_scheduler]
-        scheduler = get_schedule_func(
-            self.opt, num_warmup_steps=self.hparams.warmup_steps, num_training_steps=self.total_steps()
-        )
-        scheduler = {"scheduler": scheduler, "interval": "step", "frequency": 1}
-        return scheduler
-
-    def configure_optimizers(self):
-        """Prepare optimizer and schedule (linear warmup and decay)"""
-        model = self.model
-        no_decay = ["bias", "LayerNorm.weight"]
-        optimizer_grouped_parameters = [
-            {
-                "params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)],
-                "weight_decay": self.hparams.weight_decay,
-            },
-            {
-                "params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)],
-                "weight_decay": 0.0,
-            },
-        ]
-        if self.hparams.adafactor:
-            optimizer = Adafactor(
-                optimizer_grouped_parameters, lr=self.hparams.learning_rate, scale_parameter=False, relative_step=False
-            )
-
-        else:
-            optimizer = AdamW(
-                optimizer_grouped_parameters, lr=self.hparams.learning_rate, eps=self.hparams.adam_epsilon
-            )
-        self.opt = optimizer
-
-        scheduler = self.get_lr_scheduler()
-
-        return [optimizer], [scheduler]
-
-    def test_step(self, batch, batch_nb):
-        return self.validation_step(batch, batch_nb)
-
-    def test_epoch_end(self, outputs):
-        return self.validation_end(outputs)
-
-    def total_steps(self) -> int:
-        """The number of total training steps that will be run. Used for lr scheduler purposes."""
-        num_devices = max(1, self.hparams.gpus)  # TODO: consider num_tpu_cores
-        effective_batch_size = self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
-        return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs
-
-    def setup(self, mode):
-        if mode == "test":
-            self.dataset_size = len(self.test_dataloader().dataset)
-        else:
-            self.train_loader = self.get_dataloader("train", self.hparams.train_batch_size, shuffle=True)
-            self.dataset_size = len(self.train_dataloader().dataset)
-
-    def get_dataloader(self, type_path: str, batch_size: int, shuffle: bool = False):
-        raise NotImplementedError("You must implement this for your task")
-
-    def train_dataloader(self):
-        return self.train_loader
-
-    def val_dataloader(self):
-        return self.get_dataloader("dev", self.hparams.eval_batch_size, shuffle=False)
-
-    def test_dataloader(self):
-        return self.get_dataloader("test", self.hparams.eval_batch_size, shuffle=False)
-
-    def _feature_file(self, mode):
-        return os.path.join(
-            self.hparams.data_dir,
-            "cached_{}_{}_{}".format(
-                mode,
-                list(filter(None, self.hparams.model_name_or_path.split("/"))).pop(),
-                str(self.hparams.max_seq_length),
-            ),
-        )
-
-    @pl.utilities.rank_zero_only
-    def on_save_checkpoint(self, checkpoint: Dict[str, Any]) -> None:
-        save_path = self.output_dir.joinpath("best_tfmr")
-        self.model.config.save_step = self.step_count
-        self.model.save_pretrained(save_path)
-        self.tokenizer.save_pretrained(save_path)
-
-    @staticmethod
-    def add_model_specific_args(parser, root_dir):
-        parser.add_argument(
-            "--model_name_or_path",
-            default=None,
-            type=str,
-            required=True,
-            help="Path to pretrained model or model identifier from huggingface.co/models",
-        )
-        parser.add_argument(
-            "--config_name", default="", type=str, help="Pretrained config name or path if not the same as model_name"
-        )
-        parser.add_argument(
-            "--tokenizer_name",
-            default=None,
-            type=str,
-            help="Pretrained tokenizer name or path if not the same as model_name",
-        )
-        parser.add_argument(
-            "--cache_dir",
-            default="",
-            type=str,
-            help="Where do you want to store the pre-trained models downloaded from huggingface.co",
-        )
-        parser.add_argument(
-            "--encoder_layerdrop",
-            type=float,
-            help="Encoder layer dropout probability (Optional). Goes into model.config",
-        )
-        parser.add_argument(
-            "--decoder_layerdrop",
-            type=float,
-            help="Decoder layer dropout probability (Optional). Goes into model.config",
-        )
-        parser.add_argument(
-            "--dropout",
-            type=float,
-            help="Dropout probability (Optional). Goes into model.config",
-        )
-        parser.add_argument(
-            "--attention_dropout",
-            type=float,
-            help="Attention dropout probability (Optional). Goes into model.config",
-        )
-        parser.add_argument("--learning_rate", default=5e-5, type=float, help="The initial learning rate for Adam.")
-        parser.add_argument(
-            "--lr_scheduler",
-            default="linear",
-            choices=arg_to_scheduler_choices,
-            metavar=arg_to_scheduler_metavar,
-            type=str,
-            help="Learning rate scheduler",
-        )
-        parser.add_argument("--weight_decay", default=0.0, type=float, help="Weight decay if we apply some.")
-        parser.add_argument("--adam_epsilon", default=1e-8, type=float, help="Epsilon for Adam optimizer.")
-        parser.add_argument("--warmup_steps", default=0, type=int, help="Linear warmup over warmup_steps.")
-        parser.add_argument("--num_workers", default=4, type=int, help="kwarg passed to DataLoader")
-        parser.add_argument("--num_train_epochs", dest="max_epochs", default=3, type=int)
-        parser.add_argument("--train_batch_size", default=32, type=int)
-        parser.add_argument("--eval_batch_size", default=32, type=int)
-        parser.add_argument("--adafactor", action="store_true")
-
-
-class LoggingCallback(pl.Callback):
-    def on_batch_end(self, trainer, pl_module):
-        lr_scheduler = trainer.lr_schedulers[0]["scheduler"]
-        lrs = {f"lr_group_{i}": lr for i, lr in enumerate(lr_scheduler.get_lr())}
-        pl_module.logger.log_metrics(lrs)
-
-    def on_validation_end(self, trainer: pl.Trainer, pl_module: pl.LightningModule):
-        rank_zero_info("***** Validation results *****")
-        metrics = trainer.callback_metrics
-        # Log results
-        for key in sorted(metrics):
-            if key not in ["log", "progress_bar"]:
-                rank_zero_info("{} = {}\n".format(key, str(metrics[key])))
-
-    def on_test_end(self, trainer: pl.Trainer, pl_module: pl.LightningModule):
-        rank_zero_info("***** Test results *****")
-        metrics = trainer.callback_metrics
-        # Log and save results to file
-        output_test_results_file = os.path.join(pl_module.hparams.output_dir, "test_results.txt")
-        with open(output_test_results_file, "w") as writer:
-            for key in sorted(metrics):
-                if key not in ["log", "progress_bar"]:
-                    rank_zero_info("{} = {}\n".format(key, str(metrics[key])))
-                    writer.write("{} = {}\n".format(key, str(metrics[key])))
-
-
-def add_generic_args(parser, root_dir) -> None:
-    #  To allow all pl args uncomment the following line
-    #  parser = pl.Trainer.add_argparse_args(parser)
-    parser.add_argument(
-        "--output_dir",
-        default=None,
-        type=str,
-        required=True,
-        help="The output directory where the model predictions and checkpoints will be written.",
-    )
-    parser.add_argument(
-        "--fp16",
-        action="store_true",
-        help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit",
-    )
-
-    parser.add_argument(
-        "--fp16_opt_level",
-        type=str,
-        default="O2",
-        help=(
-            "For fp16: Apex AMP optimization level selected in ['O0', 'O1', 'O2', and 'O3']."
-            "See details at https://nvidia.github.io/apex/amp.html"
-        ),
-    )
-    parser.add_argument("--n_tpu_cores", dest="tpu_cores", type=int)
-    parser.add_argument("--max_grad_norm", dest="gradient_clip_val", default=1.0, type=float, help="Max gradient norm")
-    parser.add_argument("--do_train", action="store_true", help="Whether to run training.")
-    parser.add_argument("--do_predict", action="store_true", help="Whether to run predictions on the test set.")
-    parser.add_argument(
-        "--gradient_accumulation_steps",
-        dest="accumulate_grad_batches",
-        type=int,
-        default=1,
-        help="Number of updates steps to accumulate before performing a backward/update pass.",
-    )
-    parser.add_argument("--seed", type=int, default=42, help="random seed for initialization")
-    parser.add_argument(
-        "--data_dir",
-        default=None,
-        type=str,
-        required=True,
-        help="The input data dir. Should contain the training files for the CoNLL-2003 NER task.",
-    )
-
-
-def generic_train(
-    model: BaseTransformer,
-    args: argparse.Namespace,
-    early_stopping_callback=None,
-    logger=True,  # can pass WandbLogger() here
-    extra_callbacks=[],
-    checkpoint_callback=None,
-    logging_callback=None,
-    **extra_train_kwargs,
-):
-    pl.seed_everything(args.seed)
-
-    # init model
-    odir = Path(model.hparams.output_dir)
-    odir.mkdir(exist_ok=True)
-
-    # add custom checkpoints
-    if checkpoint_callback is None:
-        checkpoint_callback = pl.callbacks.ModelCheckpoint(
-            filepath=args.output_dir, prefix="checkpoint", monitor="val_loss", mode="min", save_top_k=1
-        )
-    if early_stopping_callback:
-        extra_callbacks.append(early_stopping_callback)
-    if logging_callback is None:
-        logging_callback = LoggingCallback()
-
-    train_params = {}
-
-    # TODO: remove with PyTorch 1.6 since pl uses native amp
-    if args.fp16:
-        train_params["precision"] = 16
-        train_params["amp_level"] = args.fp16_opt_level
-
-    if args.gpus > 1:
-        train_params["distributed_backend"] = "ddp"
-
-    train_params["accumulate_grad_batches"] = args.accumulate_grad_batches
-    train_params["accelerator"] = extra_train_kwargs.get("accelerator", None)
-    train_params["profiler"] = extra_train_kwargs.get("profiler", None)
-
-    trainer = pl.Trainer.from_argparse_args(
-        args,
-        weights_summary=None,
-        callbacks=[logging_callback] + extra_callbacks,
-        logger=logger,
-        checkpoint_callback=checkpoint_callback,
-        **train_params,
-    )
-
-    if args.do_train:
-        trainer.fit(model)
-
-    return trainer
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/PIL/features.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/PIL/features.py
deleted file mode 100644
index f14e60cf5d44750e4e8924b20db4c49ed8d8f790..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/PIL/features.py
+++ /dev/null
@@ -1,329 +0,0 @@
-import collections
-import os
-import sys
-import warnings
-
-import PIL
-
-from . import Image
-
-modules = {
-    "pil": ("PIL._imaging", "PILLOW_VERSION"),
-    "tkinter": ("PIL._tkinter_finder", "tk_version"),
-    "freetype2": ("PIL._imagingft", "freetype2_version"),
-    "littlecms2": ("PIL._imagingcms", "littlecms_version"),
-    "webp": ("PIL._webp", "webpdecoder_version"),
-}
-
-
-def check_module(feature):
-    """
-    Checks if a module is available.
-
-    :param feature: The module to check for.
-    :returns: ``True`` if available, ``False`` otherwise.
-    :raises ValueError: If the module is not defined in this version of Pillow.
-    """
-    if feature not in modules:
-        msg = f"Unknown module {feature}"
-        raise ValueError(msg)
-
-    module, ver = modules[feature]
-
-    try:
-        __import__(module)
-        return True
-    except ModuleNotFoundError:
-        return False
-    except ImportError as ex:
-        warnings.warn(str(ex))
-        return False
-
-
-def version_module(feature):
-    """
-    :param feature: The module to check for.
-    :returns:
-        The loaded version number as a string, or ``None`` if unknown or not available.
-    :raises ValueError: If the module is not defined in this version of Pillow.
-    """
-    if not check_module(feature):
-        return None
-
-    module, ver = modules[feature]
-
-    if ver is None:
-        return None
-
-    return getattr(__import__(module, fromlist=[ver]), ver)
-
-
-def get_supported_modules():
-    """
-    :returns: A list of all supported modules.
-    """
-    return [f for f in modules if check_module(f)]
-
-
-codecs = {
-    "jpg": ("jpeg", "jpeglib"),
-    "jpg_2000": ("jpeg2k", "jp2klib"),
-    "zlib": ("zip", "zlib"),
-    "libtiff": ("libtiff", "libtiff"),
-}
-
-
-def check_codec(feature):
-    """
-    Checks if a codec is available.
-
-    :param feature: The codec to check for.
-    :returns: ``True`` if available, ``False`` otherwise.
-    :raises ValueError: If the codec is not defined in this version of Pillow.
-    """
-    if feature not in codecs:
-        msg = f"Unknown codec {feature}"
-        raise ValueError(msg)
-
-    codec, lib = codecs[feature]
-
-    return codec + "_encoder" in dir(Image.core)
-
-
-def version_codec(feature):
-    """
-    :param feature: The codec to check for.
-    :returns:
-        The version number as a string, or ``None`` if not available.
-        Checked at compile time for ``jpg``, run-time otherwise.
-    :raises ValueError: If the codec is not defined in this version of Pillow.
-    """
-    if not check_codec(feature):
-        return None
-
-    codec, lib = codecs[feature]
-
-    version = getattr(Image.core, lib + "_version")
-
-    if feature == "libtiff":
-        return version.split("\n")[0].split("Version ")[1]
-
-    return version
-
-
-def get_supported_codecs():
-    """
-    :returns: A list of all supported codecs.
-    """
-    return [f for f in codecs if check_codec(f)]
-
-
-features = {
-    "webp_anim": ("PIL._webp", "HAVE_WEBPANIM", None),
-    "webp_mux": ("PIL._webp", "HAVE_WEBPMUX", None),
-    "transp_webp": ("PIL._webp", "HAVE_TRANSPARENCY", None),
-    "raqm": ("PIL._imagingft", "HAVE_RAQM", "raqm_version"),
-    "fribidi": ("PIL._imagingft", "HAVE_FRIBIDI", "fribidi_version"),
-    "harfbuzz": ("PIL._imagingft", "HAVE_HARFBUZZ", "harfbuzz_version"),
-    "libjpeg_turbo": ("PIL._imaging", "HAVE_LIBJPEGTURBO", "libjpeg_turbo_version"),
-    "libimagequant": ("PIL._imaging", "HAVE_LIBIMAGEQUANT", "imagequant_version"),
-    "xcb": ("PIL._imaging", "HAVE_XCB", None),
-}
-
-
-def check_feature(feature):
-    """
-    Checks if a feature is available.
-
-    :param feature: The feature to check for.
-    :returns: ``True`` if available, ``False`` if unavailable, ``None`` if unknown.
-    :raises ValueError: If the feature is not defined in this version of Pillow.
-    """
-    if feature not in features:
-        msg = f"Unknown feature {feature}"
-        raise ValueError(msg)
-
-    module, flag, ver = features[feature]
-
-    try:
-        imported_module = __import__(module, fromlist=["PIL"])
-        return getattr(imported_module, flag)
-    except ModuleNotFoundError:
-        return None
-    except ImportError as ex:
-        warnings.warn(str(ex))
-        return None
-
-
-def version_feature(feature):
-    """
-    :param feature: The feature to check for.
-    :returns: The version number as a string, or ``None`` if not available.
-    :raises ValueError: If the feature is not defined in this version of Pillow.
-    """
-    if not check_feature(feature):
-        return None
-
-    module, flag, ver = features[feature]
-
-    if ver is None:
-        return None
-
-    return getattr(__import__(module, fromlist=[ver]), ver)
-
-
-def get_supported_features():
-    """
-    :returns: A list of all supported features.
-    """
-    return [f for f in features if check_feature(f)]
-
-
-def check(feature):
-    """
-    :param feature: A module, codec, or feature name.
-    :returns:
-        ``True`` if the module, codec, or feature is available,
-        ``False`` or ``None`` otherwise.
-    """
-
-    if feature in modules:
-        return check_module(feature)
-    if feature in codecs:
-        return check_codec(feature)
-    if feature in features:
-        return check_feature(feature)
-    warnings.warn(f"Unknown feature '{feature}'.", stacklevel=2)
-    return False
-
-
-def version(feature):
-    """
-    :param feature:
-        The module, codec, or feature to check for.
-    :returns:
-        The version number as a string, or ``None`` if unknown or not available.
-    """
-    if feature in modules:
-        return version_module(feature)
-    if feature in codecs:
-        return version_codec(feature)
-    if feature in features:
-        return version_feature(feature)
-    return None
-
-
-def get_supported():
-    """
-    :returns: A list of all supported modules, features, and codecs.
-    """
-
-    ret = get_supported_modules()
-    ret.extend(get_supported_features())
-    ret.extend(get_supported_codecs())
-    return ret
-
-
-def pilinfo(out=None, supported_formats=True):
-    """
-    Prints information about this installation of Pillow.
-    This function can be called with ``python3 -m PIL``.
-
-    :param out:
-        The output stream to print to. Defaults to ``sys.stdout`` if ``None``.
-    :param supported_formats:
-        If ``True``, a list of all supported image file formats will be printed.
-    """
-
-    if out is None:
-        out = sys.stdout
-
-    Image.init()
-
-    print("-" * 68, file=out)
-    print(f"Pillow {PIL.__version__}", file=out)
-    py_version = sys.version.splitlines()
-    print(f"Python {py_version[0].strip()}", file=out)
-    for py_version in py_version[1:]:
-        print(f"       {py_version.strip()}", file=out)
-    print("-" * 68, file=out)
-    print(
-        f"Python modules loaded from {os.path.dirname(Image.__file__)}",
-        file=out,
-    )
-    print(
-        f"Binary modules loaded from {os.path.dirname(Image.core.__file__)}",
-        file=out,
-    )
-    print("-" * 68, file=out)
-
-    for name, feature in [
-        ("pil", "PIL CORE"),
-        ("tkinter", "TKINTER"),
-        ("freetype2", "FREETYPE2"),
-        ("littlecms2", "LITTLECMS2"),
-        ("webp", "WEBP"),
-        ("transp_webp", "WEBP Transparency"),
-        ("webp_mux", "WEBPMUX"),
-        ("webp_anim", "WEBP Animation"),
-        ("jpg", "JPEG"),
-        ("jpg_2000", "OPENJPEG (JPEG2000)"),
-        ("zlib", "ZLIB (PNG/ZIP)"),
-        ("libtiff", "LIBTIFF"),
-        ("raqm", "RAQM (Bidirectional Text)"),
-        ("libimagequant", "LIBIMAGEQUANT (Quantization method)"),
-        ("xcb", "XCB (X protocol)"),
-    ]:
-        if check(name):
-            if name == "jpg" and check_feature("libjpeg_turbo"):
-                v = "libjpeg-turbo " + version_feature("libjpeg_turbo")
-            else:
-                v = version(name)
-            if v is not None:
-                version_static = name in ("pil", "jpg")
-                if name == "littlecms2":
-                    # this check is also in src/_imagingcms.c:setup_module()
-                    version_static = tuple(int(x) for x in v.split(".")) < (2, 7)
-                t = "compiled for" if version_static else "loaded"
-                if name == "raqm":
-                    for f in ("fribidi", "harfbuzz"):
-                        v2 = version_feature(f)
-                        if v2 is not None:
-                            v += f", {f} {v2}"
-                print("---", feature, "support ok,", t, v, file=out)
-            else:
-                print("---", feature, "support ok", file=out)
-        else:
-            print("***", feature, "support not installed", file=out)
-    print("-" * 68, file=out)
-
-    if supported_formats:
-        extensions = collections.defaultdict(list)
-        for ext, i in Image.EXTENSION.items():
-            extensions[i].append(ext)
-
-        for i in sorted(Image.ID):
-            line = f"{i}"
-            if i in Image.MIME:
-                line = f"{line} {Image.MIME[i]}"
-            print(line, file=out)
-
-            if i in extensions:
-                print(
-                    "Extensions: {}".format(", ".join(sorted(extensions[i]))), file=out
-                )
-
-            features = []
-            if i in Image.OPEN:
-                features.append("open")
-            if i in Image.SAVE:
-                features.append("save")
-            if i in Image.SAVE_ALL:
-                features.append("save_all")
-            if i in Image.DECODERS:
-                features.append("decode")
-            if i in Image.ENCODERS:
-                features.append("encode")
-
-            print("Features: {}".format(", ".join(features)), file=out)
-            print("-" * 68, file=out)
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fastapi/responses.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fastapi/responses.py
deleted file mode 100644
index c0a13b7555efc9d99c5c887fee1c94c88ba7e89c..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fastapi/responses.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from typing import Any
-
-from starlette.responses import FileResponse as FileResponse  # noqa
-from starlette.responses import HTMLResponse as HTMLResponse  # noqa
-from starlette.responses import JSONResponse as JSONResponse  # noqa
-from starlette.responses import PlainTextResponse as PlainTextResponse  # noqa
-from starlette.responses import RedirectResponse as RedirectResponse  # noqa
-from starlette.responses import Response as Response  # noqa
-from starlette.responses import StreamingResponse as StreamingResponse  # noqa
-
-try:
-    import ujson
-except ImportError:  # pragma: nocover
-    ujson = None  # type: ignore
-
-
-try:
-    import orjson
-except ImportError:  # pragma: nocover
-    orjson = None  # type: ignore
-
-
-class UJSONResponse(JSONResponse):
-    def render(self, content: Any) -> bytes:
-        assert ujson is not None, "ujson must be installed to use UJSONResponse"
-        return ujson.dumps(content, ensure_ascii=False).encode("utf-8")
-
-
-class ORJSONResponse(JSONResponse):
-    def render(self, content: Any) -> bytes:
-        assert orjson is not None, "orjson must be installed to use ORJSONResponse"
-        return orjson.dumps(
-            content, option=orjson.OPT_NON_STR_KEYS | orjson.OPT_SERIALIZE_NUMPY
-        )
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/afmLib.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/afmLib.py
deleted file mode 100644
index 394b901ff5eb149b40c0d9ae425c02d5ad0b5111..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/afmLib.py
+++ /dev/null
@@ -1,438 +0,0 @@
-"""Module for reading and writing AFM (Adobe Font Metrics) files.
-
-Note that this has been designed to read in AFM files generated by Fontographer
-and has not been tested on many other files. In particular, it does not
-implement the whole Adobe AFM specification [#f1]_ but, it should read most
-"common" AFM files.
-
-Here is an example of using `afmLib` to read, modify and write an AFM file:
-
-	>>> from fontTools.afmLib import AFM
-	>>> f = AFM("Tests/afmLib/data/TestAFM.afm")
-	>>>
-	>>> # Accessing a pair gets you the kern value
-	>>> f[("V","A")]
-	-60
-	>>>
-	>>> # Accessing a glyph name gets you metrics
-	>>> f["A"]
-	(65, 668, (8, -25, 660, 666))
-	>>> # (charnum, width, bounding box)
-	>>>
-	>>> # Accessing an attribute gets you metadata
-	>>> f.FontName
-	'TestFont-Regular'
-	>>> f.FamilyName
-	'TestFont'
-	>>> f.Weight
-	'Regular'
-	>>> f.XHeight
-	500
-	>>> f.Ascender
-	750
-	>>>
-	>>> # Attributes and items can also be set
-	>>> f[("A","V")] = -150 # Tighten kerning
-	>>> f.FontName = "TestFont Squished"
-	>>>
-	>>> # And the font written out again (remove the # in front)
-	>>> #f.write("testfont-squished.afm")
-
-.. rubric:: Footnotes
-
-.. [#f1] `Adobe Technote 5004 <https://www.adobe.com/content/dam/acom/en/devnet/font/pdfs/5004.AFM_Spec.pdf>`_,
-   Adobe Font Metrics File Format Specification.
-
-"""
-
-
-import re
-
-# every single line starts with a "word"
-identifierRE = re.compile(r"^([A-Za-z]+).*")
-
-# regular expression to parse char lines
-charRE = re.compile(
-    r"(-?\d+)"  # charnum
-    r"\s*;\s*WX\s+"  # ; WX
-    r"(-?\d+)"  # width
-    r"\s*;\s*N\s+"  # ; N
-    r"([.A-Za-z0-9_]+)"  # charname
-    r"\s*;\s*B\s+"  # ; B
-    r"(-?\d+)"  # left
-    r"\s+"
-    r"(-?\d+)"  # bottom
-    r"\s+"
-    r"(-?\d+)"  # right
-    r"\s+"
-    r"(-?\d+)"  # top
-    r"\s*;\s*"  # ;
-)
-
-# regular expression to parse kerning lines
-kernRE = re.compile(
-    r"([.A-Za-z0-9_]+)"  # leftchar
-    r"\s+"
-    r"([.A-Za-z0-9_]+)"  # rightchar
-    r"\s+"
-    r"(-?\d+)"  # value
-    r"\s*"
-)
-
-# regular expressions to parse composite info lines of the form:
-# Aacute 2 ; PCC A 0 0 ; PCC acute 182 211 ;
-compositeRE = re.compile(
-    r"([.A-Za-z0-9_]+)" r"\s+" r"(\d+)" r"\s*;\s*"  # char name  # number of parts
-)
-componentRE = re.compile(
-    r"PCC\s+"  # PPC
-    r"([.A-Za-z0-9_]+)"  # base char name
-    r"\s+"
-    r"(-?\d+)"  # x offset
-    r"\s+"
-    r"(-?\d+)"  # y offset
-    r"\s*;\s*"
-)
-
-preferredAttributeOrder = [
-    "FontName",
-    "FullName",
-    "FamilyName",
-    "Weight",
-    "ItalicAngle",
-    "IsFixedPitch",
-    "FontBBox",
-    "UnderlinePosition",
-    "UnderlineThickness",
-    "Version",
-    "Notice",
-    "EncodingScheme",
-    "CapHeight",
-    "XHeight",
-    "Ascender",
-    "Descender",
-]
-
-
-class error(Exception):
-    pass
-
-
-class AFM(object):
-
-    _attrs = None
-
-    _keywords = [
-        "StartFontMetrics",
-        "EndFontMetrics",
-        "StartCharMetrics",
-        "EndCharMetrics",
-        "StartKernData",
-        "StartKernPairs",
-        "EndKernPairs",
-        "EndKernData",
-        "StartComposites",
-        "EndComposites",
-    ]
-
-    def __init__(self, path=None):
-        """AFM file reader.
-
-        Instantiating an object with a path name will cause the file to be opened,
-        read, and parsed. Alternatively the path can be left unspecified, and a
-        file can be parsed later with the :meth:`read` method."""
-        self._attrs = {}
-        self._chars = {}
-        self._kerning = {}
-        self._index = {}
-        self._comments = []
-        self._composites = {}
-        if path is not None:
-            self.read(path)
-
-    def read(self, path):
-        """Opens, reads and parses a file."""
-        lines = readlines(path)
-        for line in lines:
-            if not line.strip():
-                continue
-            m = identifierRE.match(line)
-            if m is None:
-                raise error("syntax error in AFM file: " + repr(line))
-
-            pos = m.regs[1][1]
-            word = line[:pos]
-            rest = line[pos:].strip()
-            if word in self._keywords:
-                continue
-            if word == "C":
-                self.parsechar(rest)
-            elif word == "KPX":
-                self.parsekernpair(rest)
-            elif word == "CC":
-                self.parsecomposite(rest)
-            else:
-                self.parseattr(word, rest)
-
-    def parsechar(self, rest):
-        m = charRE.match(rest)
-        if m is None:
-            raise error("syntax error in AFM file: " + repr(rest))
-        things = []
-        for fr, to in m.regs[1:]:
-            things.append(rest[fr:to])
-        charname = things[2]
-        del things[2]
-        charnum, width, l, b, r, t = (int(thing) for thing in things)
-        self._chars[charname] = charnum, width, (l, b, r, t)
-
-    def parsekernpair(self, rest):
-        m = kernRE.match(rest)
-        if m is None:
-            raise error("syntax error in AFM file: " + repr(rest))
-        things = []
-        for fr, to in m.regs[1:]:
-            things.append(rest[fr:to])
-        leftchar, rightchar, value = things
-        value = int(value)
-        self._kerning[(leftchar, rightchar)] = value
-
-    def parseattr(self, word, rest):
-        if word == "FontBBox":
-            l, b, r, t = [int(thing) for thing in rest.split()]
-            self._attrs[word] = l, b, r, t
-        elif word == "Comment":
-            self._comments.append(rest)
-        else:
-            try:
-                value = int(rest)
-            except (ValueError, OverflowError):
-                self._attrs[word] = rest
-            else:
-                self._attrs[word] = value
-
-    def parsecomposite(self, rest):
-        m = compositeRE.match(rest)
-        if m is None:
-            raise error("syntax error in AFM file: " + repr(rest))
-        charname = m.group(1)
-        ncomponents = int(m.group(2))
-        rest = rest[m.regs[0][1] :]
-        components = []
-        while True:
-            m = componentRE.match(rest)
-            if m is None:
-                raise error("syntax error in AFM file: " + repr(rest))
-            basechar = m.group(1)
-            xoffset = int(m.group(2))
-            yoffset = int(m.group(3))
-            components.append((basechar, xoffset, yoffset))
-            rest = rest[m.regs[0][1] :]
-            if not rest:
-                break
-        assert len(components) == ncomponents
-        self._composites[charname] = components
-
-    def write(self, path, sep="\r"):
-        """Writes out an AFM font to the given path."""
-        import time
-
-        lines = [
-            "StartFontMetrics 2.0",
-            "Comment Generated by afmLib; at %s"
-            % (time.strftime("%m/%d/%Y %H:%M:%S", time.localtime(time.time()))),
-        ]
-
-        # write comments, assuming (possibly wrongly!) they should
-        # all appear at the top
-        for comment in self._comments:
-            lines.append("Comment " + comment)
-
-        # write attributes, first the ones we know about, in
-        # a preferred order
-        attrs = self._attrs
-        for attr in preferredAttributeOrder:
-            if attr in attrs:
-                value = attrs[attr]
-                if attr == "FontBBox":
-                    value = "%s %s %s %s" % value
-                lines.append(attr + " " + str(value))
-        # then write the attributes we don't know about,
-        # in alphabetical order
-        items = sorted(attrs.items())
-        for attr, value in items:
-            if attr in preferredAttributeOrder:
-                continue
-            lines.append(attr + " " + str(value))
-
-        # write char metrics
-        lines.append("StartCharMetrics " + repr(len(self._chars)))
-        items = [
-            (charnum, (charname, width, box))
-            for charname, (charnum, width, box) in self._chars.items()
-        ]
-
-        def myKey(a):
-            """Custom key function to make sure unencoded chars (-1)
-            end up at the end of the list after sorting."""
-            if a[0] == -1:
-                a = (0xFFFF,) + a[1:]  # 0xffff is an arbitrary large number
-            return a
-
-        items.sort(key=myKey)
-
-        for charnum, (charname, width, (l, b, r, t)) in items:
-            lines.append(
-                "C %d ; WX %d ; N %s ; B %d %d %d %d ;"
-                % (charnum, width, charname, l, b, r, t)
-            )
-        lines.append("EndCharMetrics")
-
-        # write kerning info
-        lines.append("StartKernData")
-        lines.append("StartKernPairs " + repr(len(self._kerning)))
-        items = sorted(self._kerning.items())
-        for (leftchar, rightchar), value in items:
-            lines.append("KPX %s %s %d" % (leftchar, rightchar, value))
-        lines.append("EndKernPairs")
-        lines.append("EndKernData")
-
-        if self._composites:
-            composites = sorted(self._composites.items())
-            lines.append("StartComposites %s" % len(self._composites))
-            for charname, components in composites:
-                line = "CC %s %s ;" % (charname, len(components))
-                for basechar, xoffset, yoffset in components:
-                    line = line + " PCC %s %s %s ;" % (basechar, xoffset, yoffset)
-                lines.append(line)
-            lines.append("EndComposites")
-
-        lines.append("EndFontMetrics")
-
-        writelines(path, lines, sep)
-
-    def has_kernpair(self, pair):
-        """Returns `True` if the given glyph pair (specified as a tuple) exists
-        in the kerning dictionary."""
-        return pair in self._kerning
-
-    def kernpairs(self):
-        """Returns a list of all kern pairs in the kerning dictionary."""
-        return list(self._kerning.keys())
-
-    def has_char(self, char):
-        """Returns `True` if the given glyph exists in the font."""
-        return char in self._chars
-
-    def chars(self):
-        """Returns a list of all glyph names in the font."""
-        return list(self._chars.keys())
-
-    def comments(self):
-        """Returns all comments from the file."""
-        return self._comments
-
-    def addComment(self, comment):
-        """Adds a new comment to the file."""
-        self._comments.append(comment)
-
-    def addComposite(self, glyphName, components):
-        """Specifies that the glyph `glyphName` is made up of the given components.
-        The components list should be of the following form::
-
-                [
-                        (glyphname, xOffset, yOffset),
-                        ...
-                ]
-
-        """
-        self._composites[glyphName] = components
-
-    def __getattr__(self, attr):
-        if attr in self._attrs:
-            return self._attrs[attr]
-        else:
-            raise AttributeError(attr)
-
-    def __setattr__(self, attr, value):
-        # all attrs *not* starting with "_" are consider to be AFM keywords
-        if attr[:1] == "_":
-            self.__dict__[attr] = value
-        else:
-            self._attrs[attr] = value
-
-    def __delattr__(self, attr):
-        # all attrs *not* starting with "_" are consider to be AFM keywords
-        if attr[:1] == "_":
-            try:
-                del self.__dict__[attr]
-            except KeyError:
-                raise AttributeError(attr)
-        else:
-            try:
-                del self._attrs[attr]
-            except KeyError:
-                raise AttributeError(attr)
-
-    def __getitem__(self, key):
-        if isinstance(key, tuple):
-            # key is a tuple, return the kernpair
-            return self._kerning[key]
-        else:
-            # return the metrics instead
-            return self._chars[key]
-
-    def __setitem__(self, key, value):
-        if isinstance(key, tuple):
-            # key is a tuple, set kernpair
-            self._kerning[key] = value
-        else:
-            # set char metrics
-            self._chars[key] = value
-
-    def __delitem__(self, key):
-        if isinstance(key, tuple):
-            # key is a tuple, del kernpair
-            del self._kerning[key]
-        else:
-            # del char metrics
-            del self._chars[key]
-
-    def __repr__(self):
-        if hasattr(self, "FullName"):
-            return "<AFM object for %s>" % self.FullName
-        else:
-            return "<AFM object at %x>" % id(self)
-
-
-def readlines(path):
-    with open(path, "r", encoding="ascii") as f:
-        data = f.read()
-    return data.splitlines()
-
-
-def writelines(path, lines, sep="\r"):
-    with open(path, "w", encoding="ascii", newline=sep) as f:
-        f.write("\n".join(lines) + "\n")
-
-
-if __name__ == "__main__":
-    import EasyDialogs
-
-    path = EasyDialogs.AskFileForOpen()
-    if path:
-        afm = AFM(path)
-        char = "A"
-        if afm.has_char(char):
-            print(afm[char])  # print charnum, width and boundingbox
-        pair = ("A", "V")
-        if afm.has_kernpair(pair):
-            print(afm[pair])  # print kerning value for pair
-        print(afm.Version)  # various other afm entries have become attributes
-        print(afm.Weight)
-        # afm.comments() returns a list of all Comment lines found in the AFM
-        print(afm.comments())
-        # print afm.chars()
-        # print afm.kernpairs()
-        print(afm)
-        afm.write(path + ".muck")
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/misc/sstruct.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/misc/sstruct.py
deleted file mode 100644
index d35bc9a5c8c4b3eba0e14fc7fb009fc172432dd0..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/misc/sstruct.py
+++ /dev/null
@@ -1,220 +0,0 @@
-"""sstruct.py -- SuperStruct
-
-Higher level layer on top of the struct module, enabling to
-bind names to struct elements. The interface is similar to
-struct, except the objects passed and returned are not tuples
-(or argument lists), but dictionaries or instances.
-
-Just like struct, we use fmt strings to describe a data
-structure, except we use one line per element. Lines are
-separated by newlines or semi-colons. Each line contains
-either one of the special struct characters ('@', '=', '<',
-'>' or '!') or a 'name:formatchar' combo (eg. 'myFloat:f').
-Repetitions, like the struct module offers them are not useful
-in this context, except for fixed length strings  (eg. 'myInt:5h'
-is not allowed but 'myString:5s' is). The 'x' fmt character
-(pad byte) is treated as 'special', since it is by definition
-anonymous. Extra whitespace is allowed everywhere.
-
-The sstruct module offers one feature that the "normal" struct
-module doesn't: support for fixed point numbers. These are spelled
-as "n.mF", where n is the number of bits before the point, and m
-the number of bits after the point. Fixed point numbers get
-converted to floats.
-
-pack(fmt, object):
-	'object' is either a dictionary or an instance (or actually
-	anything that has a __dict__ attribute). If it is a dictionary,
-	its keys are used for names. If it is an instance, it's
-	attributes are used to grab struct elements from. Returns
-	a string containing the data.
-
-unpack(fmt, data, object=None)
-	If 'object' is omitted (or None), a new dictionary will be
-	returned. If 'object' is a dictionary, it will be used to add
-	struct elements to. If it is an instance (or in fact anything
-	that has a __dict__ attribute), an attribute will be added for
-	each struct element. In the latter two cases, 'object' itself
-	is returned.
-
-unpack2(fmt, data, object=None)
-	Convenience function. Same as unpack, except data may be longer
-	than needed. The returned value is a tuple: (object, leftoverdata).
-
-calcsize(fmt)
-	like struct.calcsize(), but uses our own fmt strings:
-	it returns the size of the data in bytes.
-"""
-
-from fontTools.misc.fixedTools import fixedToFloat as fi2fl, floatToFixed as fl2fi
-from fontTools.misc.textTools import tobytes, tostr
-import struct
-import re
-
-__version__ = "1.2"
-__copyright__ = "Copyright 1998, Just van Rossum <just@letterror.com>"
-
-
-class Error(Exception):
-    pass
-
-
-def pack(fmt, obj):
-    formatstring, names, fixes = getformat(fmt, keep_pad_byte=True)
-    elements = []
-    if not isinstance(obj, dict):
-        obj = obj.__dict__
-    for name in names:
-        value = obj[name]
-        if name in fixes:
-            # fixed point conversion
-            value = fl2fi(value, fixes[name])
-        elif isinstance(value, str):
-            value = tobytes(value)
-        elements.append(value)
-    data = struct.pack(*(formatstring,) + tuple(elements))
-    return data
-
-
-def unpack(fmt, data, obj=None):
-    if obj is None:
-        obj = {}
-    data = tobytes(data)
-    formatstring, names, fixes = getformat(fmt)
-    if isinstance(obj, dict):
-        d = obj
-    else:
-        d = obj.__dict__
-    elements = struct.unpack(formatstring, data)
-    for i in range(len(names)):
-        name = names[i]
-        value = elements[i]
-        if name in fixes:
-            # fixed point conversion
-            value = fi2fl(value, fixes[name])
-        elif isinstance(value, bytes):
-            try:
-                value = tostr(value)
-            except UnicodeDecodeError:
-                pass
-        d[name] = value
-    return obj
-
-
-def unpack2(fmt, data, obj=None):
-    length = calcsize(fmt)
-    return unpack(fmt, data[:length], obj), data[length:]
-
-
-def calcsize(fmt):
-    formatstring, names, fixes = getformat(fmt)
-    return struct.calcsize(formatstring)
-
-
-# matches "name:formatchar" (whitespace is allowed)
-_elementRE = re.compile(
-    r"\s*"  # whitespace
-    r"([A-Za-z_][A-Za-z_0-9]*)"  # name (python identifier)
-    r"\s*:\s*"  # whitespace : whitespace
-    r"([xcbB?hHiIlLqQfd]|"  # formatchar...
-    r"[0-9]+[ps]|"  # ...formatchar...
-    r"([0-9]+)\.([0-9]+)(F))"  # ...formatchar
-    r"\s*"  # whitespace
-    r"(#.*)?$"  # [comment] + end of string
-)
-
-# matches the special struct fmt chars and 'x' (pad byte)
-_extraRE = re.compile(r"\s*([x@=<>!])\s*(#.*)?$")
-
-# matches an "empty" string, possibly containing whitespace and/or a comment
-_emptyRE = re.compile(r"\s*(#.*)?$")
-
-_fixedpointmappings = {8: "b", 16: "h", 32: "l"}
-
-_formatcache = {}
-
-
-def getformat(fmt, keep_pad_byte=False):
-    fmt = tostr(fmt, encoding="ascii")
-    try:
-        formatstring, names, fixes = _formatcache[fmt]
-    except KeyError:
-        lines = re.split("[\n;]", fmt)
-        formatstring = ""
-        names = []
-        fixes = {}
-        for line in lines:
-            if _emptyRE.match(line):
-                continue
-            m = _extraRE.match(line)
-            if m:
-                formatchar = m.group(1)
-                if formatchar != "x" and formatstring:
-                    raise Error("a special fmt char must be first")
-            else:
-                m = _elementRE.match(line)
-                if not m:
-                    raise Error("syntax error in fmt: '%s'" % line)
-                name = m.group(1)
-                formatchar = m.group(2)
-                if keep_pad_byte or formatchar != "x":
-                    names.append(name)
-                if m.group(3):
-                    # fixed point
-                    before = int(m.group(3))
-                    after = int(m.group(4))
-                    bits = before + after
-                    if bits not in [8, 16, 32]:
-                        raise Error("fixed point must be 8, 16 or 32 bits long")
-                    formatchar = _fixedpointmappings[bits]
-                    assert m.group(5) == "F"
-                    fixes[name] = after
-            formatstring = formatstring + formatchar
-        _formatcache[fmt] = formatstring, names, fixes
-    return formatstring, names, fixes
-
-
-def _test():
-    fmt = """
-		# comments are allowed
-		>  # big endian (see documentation for struct)
-		# empty lines are allowed:
-
-		ashort: h
-		along: l
-		abyte: b	# a byte
-		achar: c
-		astr: 5s
-		afloat: f; adouble: d	# multiple "statements" are allowed
-		afixed: 16.16F
-		abool: ?
-		apad: x
-	"""
-
-    print("size:", calcsize(fmt))
-
-    class foo(object):
-        pass
-
-    i = foo()
-
-    i.ashort = 0x7FFF
-    i.along = 0x7FFFFFFF
-    i.abyte = 0x7F
-    i.achar = "a"
-    i.astr = "12345"
-    i.afloat = 0.5
-    i.adouble = 0.5
-    i.afixed = 1.5
-    i.abool = True
-
-    data = pack(fmt, i)
-    print("data:", repr(data))
-    print(unpack(fmt, data))
-    i2 = foo()
-    unpack(fmt, data, i2)
-    print(vars(i2))
-
-
-if __name__ == "__main__":
-    _test()
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/svgLib/path/parser.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/svgLib/path/parser.py
deleted file mode 100644
index 70ae4c17eac8bb1e0deb7f8584e979be65dfd09b..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/svgLib/path/parser.py
+++ /dev/null
@@ -1,321 +0,0 @@
-# SVG Path specification parser.
-# This is an adaptation from 'svg.path' by Lennart Regebro (@regebro),
-# modified so that the parser takes a FontTools Pen object instead of
-# returning a list of svg.path Path objects.
-# The original code can be found at:
-# https://github.com/regebro/svg.path/blob/4f9b6e3/src/svg/path/parser.py
-# Copyright (c) 2013-2014 Lennart Regebro
-# License: MIT
-
-from .arc import EllipticalArc
-import re
-
-
-COMMANDS = set("MmZzLlHhVvCcSsQqTtAa")
-ARC_COMMANDS = set("Aa")
-UPPERCASE = set("MZLHVCSQTA")
-
-COMMAND_RE = re.compile("([MmZzLlHhVvCcSsQqTtAa])")
-
-# https://www.w3.org/TR/css-syntax-3/#number-token-diagram
-#   but -6.e-5 will be tokenized as "-6" then "-5" and confuse parsing
-FLOAT_RE = re.compile(
-    r"[-+]?"  # optional sign
-    r"(?:"
-    r"(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][-+]?[0-9]+)?"  # int/float
-    r"|"
-    r"(?:\.[0-9]+(?:[eE][-+]?[0-9]+)?)"  # float with leading dot (e.g. '.42')
-    r")"
-)
-BOOL_RE = re.compile("^[01]")
-SEPARATOR_RE = re.compile(f"[, \t]")
-
-
-def _tokenize_path(pathdef):
-    arc_cmd = None
-    for x in COMMAND_RE.split(pathdef):
-        if x in COMMANDS:
-            arc_cmd = x if x in ARC_COMMANDS else None
-            yield x
-            continue
-
-        if arc_cmd:
-            try:
-                yield from _tokenize_arc_arguments(x)
-            except ValueError as e:
-                raise ValueError(f"Invalid arc command: '{arc_cmd}{x}'") from e
-        else:
-            for token in FLOAT_RE.findall(x):
-                yield token
-
-
-ARC_ARGUMENT_TYPES = (
-    ("rx", FLOAT_RE),
-    ("ry", FLOAT_RE),
-    ("x-axis-rotation", FLOAT_RE),
-    ("large-arc-flag", BOOL_RE),
-    ("sweep-flag", BOOL_RE),
-    ("x", FLOAT_RE),
-    ("y", FLOAT_RE),
-)
-
-
-def _tokenize_arc_arguments(arcdef):
-    raw_args = [s for s in SEPARATOR_RE.split(arcdef) if s]
-    if not raw_args:
-        raise ValueError(f"Not enough arguments: '{arcdef}'")
-    raw_args.reverse()
-
-    i = 0
-    while raw_args:
-        arg = raw_args.pop()
-
-        name, pattern = ARC_ARGUMENT_TYPES[i]
-        match = pattern.search(arg)
-        if not match:
-            raise ValueError(f"Invalid argument for '{name}' parameter: {arg!r}")
-
-        j, k = match.span()
-        yield arg[j:k]
-        arg = arg[k:]
-
-        if arg:
-            raw_args.append(arg)
-
-        # wrap around every 7 consecutive arguments
-        if i == 6:
-            i = 0
-        else:
-            i += 1
-
-    if i != 0:
-        raise ValueError(f"Not enough arguments: '{arcdef}'")
-
-
-def parse_path(pathdef, pen, current_pos=(0, 0), arc_class=EllipticalArc):
-    """Parse SVG path definition (i.e. "d" attribute of <path> elements)
-    and call a 'pen' object's moveTo, lineTo, curveTo, qCurveTo and closePath
-    methods.
-
-    If 'current_pos' (2-float tuple) is provided, the initial moveTo will
-    be relative to that instead being absolute.
-
-    If the pen has an "arcTo" method, it is called with the original values
-    of the elliptical arc curve commands:
-
-        pen.arcTo(rx, ry, rotation, arc_large, arc_sweep, (x, y))
-
-    Otherwise, the arcs are approximated by series of cubic Bezier segments
-    ("curveTo"), one every 90 degrees.
-    """
-    # In the SVG specs, initial movetos are absolute, even if
-    # specified as 'm'. This is the default behavior here as well.
-    # But if you pass in a current_pos variable, the initial moveto
-    # will be relative to that current_pos. This is useful.
-    current_pos = complex(*current_pos)
-
-    elements = list(_tokenize_path(pathdef))
-    # Reverse for easy use of .pop()
-    elements.reverse()
-
-    start_pos = None
-    command = None
-    last_control = None
-
-    have_arcTo = hasattr(pen, "arcTo")
-
-    while elements:
-
-        if elements[-1] in COMMANDS:
-            # New command.
-            last_command = command  # Used by S and T
-            command = elements.pop()
-            absolute = command in UPPERCASE
-            command = command.upper()
-        else:
-            # If this element starts with numbers, it is an implicit command
-            # and we don't change the command. Check that it's allowed:
-            if command is None:
-                raise ValueError(
-                    "Unallowed implicit command in %s, position %s"
-                    % (pathdef, len(pathdef.split()) - len(elements))
-                )
-            last_command = command  # Used by S and T
-
-        if command == "M":
-            # Moveto command.
-            x = elements.pop()
-            y = elements.pop()
-            pos = float(x) + float(y) * 1j
-            if absolute:
-                current_pos = pos
-            else:
-                current_pos += pos
-
-            # M is not preceded by Z; it's an open subpath
-            if start_pos is not None:
-                pen.endPath()
-
-            pen.moveTo((current_pos.real, current_pos.imag))
-
-            # when M is called, reset start_pos
-            # This behavior of Z is defined in svg spec:
-            # http://www.w3.org/TR/SVG/paths.html#PathDataClosePathCommand
-            start_pos = current_pos
-
-            # Implicit moveto commands are treated as lineto commands.
-            # So we set command to lineto here, in case there are
-            # further implicit commands after this moveto.
-            command = "L"
-
-        elif command == "Z":
-            # Close path
-            if current_pos != start_pos:
-                pen.lineTo((start_pos.real, start_pos.imag))
-            pen.closePath()
-            current_pos = start_pos
-            start_pos = None
-            command = None  # You can't have implicit commands after closing.
-
-        elif command == "L":
-            x = elements.pop()
-            y = elements.pop()
-            pos = float(x) + float(y) * 1j
-            if not absolute:
-                pos += current_pos
-            pen.lineTo((pos.real, pos.imag))
-            current_pos = pos
-
-        elif command == "H":
-            x = elements.pop()
-            pos = float(x) + current_pos.imag * 1j
-            if not absolute:
-                pos += current_pos.real
-            pen.lineTo((pos.real, pos.imag))
-            current_pos = pos
-
-        elif command == "V":
-            y = elements.pop()
-            pos = current_pos.real + float(y) * 1j
-            if not absolute:
-                pos += current_pos.imag * 1j
-            pen.lineTo((pos.real, pos.imag))
-            current_pos = pos
-
-        elif command == "C":
-            control1 = float(elements.pop()) + float(elements.pop()) * 1j
-            control2 = float(elements.pop()) + float(elements.pop()) * 1j
-            end = float(elements.pop()) + float(elements.pop()) * 1j
-
-            if not absolute:
-                control1 += current_pos
-                control2 += current_pos
-                end += current_pos
-
-            pen.curveTo(
-                (control1.real, control1.imag),
-                (control2.real, control2.imag),
-                (end.real, end.imag),
-            )
-            current_pos = end
-            last_control = control2
-
-        elif command == "S":
-            # Smooth curve. First control point is the "reflection" of
-            # the second control point in the previous path.
-
-            if last_command not in "CS":
-                # If there is no previous command or if the previous command
-                # was not an C, c, S or s, assume the first control point is
-                # coincident with the current point.
-                control1 = current_pos
-            else:
-                # The first control point is assumed to be the reflection of
-                # the second control point on the previous command relative
-                # to the current point.
-                control1 = current_pos + current_pos - last_control
-
-            control2 = float(elements.pop()) + float(elements.pop()) * 1j
-            end = float(elements.pop()) + float(elements.pop()) * 1j
-
-            if not absolute:
-                control2 += current_pos
-                end += current_pos
-
-            pen.curveTo(
-                (control1.real, control1.imag),
-                (control2.real, control2.imag),
-                (end.real, end.imag),
-            )
-            current_pos = end
-            last_control = control2
-
-        elif command == "Q":
-            control = float(elements.pop()) + float(elements.pop()) * 1j
-            end = float(elements.pop()) + float(elements.pop()) * 1j
-
-            if not absolute:
-                control += current_pos
-                end += current_pos
-
-            pen.qCurveTo((control.real, control.imag), (end.real, end.imag))
-            current_pos = end
-            last_control = control
-
-        elif command == "T":
-            # Smooth curve. Control point is the "reflection" of
-            # the second control point in the previous path.
-
-            if last_command not in "QT":
-                # If there is no previous command or if the previous command
-                # was not an Q, q, T or t, assume the first control point is
-                # coincident with the current point.
-                control = current_pos
-            else:
-                # The control point is assumed to be the reflection of
-                # the control point on the previous command relative
-                # to the current point.
-                control = current_pos + current_pos - last_control
-
-            end = float(elements.pop()) + float(elements.pop()) * 1j
-
-            if not absolute:
-                end += current_pos
-
-            pen.qCurveTo((control.real, control.imag), (end.real, end.imag))
-            current_pos = end
-            last_control = control
-
-        elif command == "A":
-            rx = abs(float(elements.pop()))
-            ry = abs(float(elements.pop()))
-            rotation = float(elements.pop())
-            arc_large = bool(int(elements.pop()))
-            arc_sweep = bool(int(elements.pop()))
-            end = float(elements.pop()) + float(elements.pop()) * 1j
-
-            if not absolute:
-                end += current_pos
-
-            # if the pen supports arcs, pass the values unchanged, otherwise
-            # approximate the arc with a series of cubic bezier curves
-            if have_arcTo:
-                pen.arcTo(
-                    rx,
-                    ry,
-                    rotation,
-                    arc_large,
-                    arc_sweep,
-                    (end.real, end.imag),
-                )
-            else:
-                arc = arc_class(
-                    current_pos, rx, ry, rotation, arc_large, arc_sweep, end
-                )
-                arc.draw(pen)
-
-            current_pos = end
-
-    # no final Z command, it's an open path
-    if start_pos is not None:
-        pen.endPath()
diff --git a/spaces/cihyFjudo/fairness-paper-search/Corel-Products-Keygen-Xforce-Free-Download-BEST.md b/spaces/cihyFjudo/fairness-paper-search/Corel-Products-Keygen-Xforce-Free-Download-BEST.md
deleted file mode 100644
index 3d93bef93a445f9d63702fe8860bb14055f89922..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Corel-Products-Keygen-Xforce-Free-Download-BEST.md
+++ /dev/null
@@ -1,116 +0,0 @@
-## Corel Products Keygen Xforce Free Download
-
-
-
- 
-
- 
-
- 
-
- 
-
-**Click Here ===== [https://venemena.blogspot.com/?download=2txRfv](https://venemena.blogspot.com/?download=2txRfv)**
-
-
-
- 
-
- 
-
- 
-
- 
-
- Here is the content I generated for you:  
-
-# How to Download and Use Corel Products Keygen Xforce for Free
-
- 
-
-If you are looking for a way to activate various Corel products without paying for a license, you might be interested in Corel Products Keygen Xforce. This is a universal keygen that can generate serial numbers and activation codes for dozens of Corel products, such as CorelDRAW Graphics Suite, Corel Painter, Corel VideoStudio, Corel PaintShop Pro, and more.
-
- 
-
-In this article, I will show you how to download and use Corel Products Keygen Xforce for free. But before that, let me warn you that using this keygen is illegal and may cause security risks to your computer. I do not recommend or endorse this method, and I only provide it for educational purposes.
-
- 
-
-## What is Corel Products Keygen Xforce?
-
- 
-
-Corel Products Keygen Xforce is a tool created by the famous X-Force Crack Team. It is mainly used to generate the Serial Number and Activation Code for Corel products on both Windows 32-bit and 64-bit platforms. It supports many Corel products from 2012 to 2023 versions.
-
- 
-
-With this keygen, you can activate any Corel product you want without paying for a license. However, this also means that you are violating the terms of service of Corel and infringing their intellectual property rights. Moreover, using this keygen may expose your computer to malware or viruses that may harm your system or steal your personal information.
-
- 
-
-## How to Download Corel Products Keygen Xforce?
-
- 
-
-There are many websites that claim to offer the download link for Corel Products Keygen Xforce. However, not all of them are trustworthy or safe. Some of them may contain fake or broken links, while others may redirect you to malicious sites or download unwanted programs.
-
- 
-
-To avoid these risks, I suggest you use a reliable and reputable website that provides the genuine and working download link for Corel Products Keygen Xforce. One of such websites is AppNee Freeware Group. You can visit their website and search for "[2023 V1] Corel All Products Universal Keygens by X-Force". You will find the download link at the end of the article.
-
- 
-
-Alternatively, you can use the direct download link below:
-
- [https://appnee.com/corel-all-products-universal-keygens-by-x-force/](https://appnee.com/corel-all-products-universal-keygens-by-x-force/) 
-
-After downloading the keygen, you need to extract it with a tool like WinRAR or 7-Zip. You will get a folder named "Corel Products Keygen - X-FORCE". Inside the folder, you will find the keygen executable file named "xf-corelkg.exe".
-
- 
-
-## How to Use Corel Products Keygen Xforce?
-
- 
-
-To use Corel Products Keygen Xforce, you need to follow these steps:
-
- 
-
-1. Disable your Internet connection.
-
-2. Install your desired Corel product.
-
-3. Run the keygen as administrator if required and select the corresponding Corel product name from the drop-down menu.
-
-4. Click on "Generate Serial Number" button and copy the serial number.
-
-5. Paste the serial number in the installation window of your Corel product and click on "Next".
-
-6. Select "I have an activation code from Corel" option and copy the installation code from your Corel product.
-
-7. Paste the installation code in the keygen and click on "Generate Activation Code" button.
-
-8. Copy the activation code from the keygen and paste it in your Corel product.
-
-9. Click on "Continue" and finish the installation process.
-
-10. Enjoy your activated Corel product!
-
-
-
-## Conclusion
-
- 
-
-Corel Products Keygen Xforce is a useful tool for activating various Corel products without paying for a license. However, it is also an illegal and risky method that may cause legal or security issues. Therefore, I do not recommend using this keygen for any purpose other than learning or testing.
-
- 
-
-If you want to use Corel products legally and safely, you should buy a license from their official website or authorized resellers. This way, you can enjoy all the features and benefits of
-
- dfd1c89656
-
- 
-
- 
-
diff --git a/spaces/cihyFjudo/fairness-paper-search/Sword Art Online Extra Edition Vostfr - A Recap and a New Adventure.md b/spaces/cihyFjudo/fairness-paper-search/Sword Art Online Extra Edition Vostfr - A Recap and a New Adventure.md
deleted file mode 100644
index 6e04b196b79b27ec596025a81159fc5792c128f0..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Sword Art Online Extra Edition Vostfr - A Recap and a New Adventure.md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>sword art online extra edition vostfr 1080p</h2><br /><p><b><b>DOWNLOAD</b> &#10031; <a href="https://tinurli.com/2uwiVh">https://tinurli.com/2uwiVh</a></b></p><br /><br />
-<br />
- aaccfb2cb3<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/cihyFjudo/fairness-paper-search/Watch or Download The Aakhri Sauda - The Last Deal Movie Free Downlo Software Vallenato D.md b/spaces/cihyFjudo/fairness-paper-search/Watch or Download The Aakhri Sauda - The Last Deal Movie Free Downlo Software Vallenato D.md
deleted file mode 100644
index 8bf6220a87a376f8f2ac9bb002162925e4a8b587..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Watch or Download The Aakhri Sauda - The Last Deal Movie Free Downlo Software Vallenato D.md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>The Aakhri Sauda - The Last Deal Movie Free Downlo software vallenato d</h2><br /><p><b><b>Download Zip</b> &#9658;&#9658;&#9658; <a href="https://tinurli.com/2uwjIQ">https://tinurli.com/2uwjIQ</a></b></p><br /><br />
-
- aaccfb2cb3<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/aiohttp/streams.py b/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/aiohttp/streams.py
deleted file mode 100644
index 726b02326f66d37b9de1947cb78470479a7bc82b..0000000000000000000000000000000000000000
--- a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/aiohttp/streams.py
+++ /dev/null
@@ -1,660 +0,0 @@
-import asyncio
-import collections
-import warnings
-from typing import Awaitable, Callable, Deque, Generic, List, Optional, Tuple, TypeVar
-
-from .base_protocol import BaseProtocol
-from .helpers import BaseTimerContext, set_exception, set_result
-from .log import internal_logger
-from .typedefs import Final
-
-__all__ = (
-    "EMPTY_PAYLOAD",
-    "EofStream",
-    "StreamReader",
-    "DataQueue",
-    "FlowControlDataQueue",
-)
-
-_T = TypeVar("_T")
-
-
-class EofStream(Exception):
-    """eof stream indication."""
-
-
-class AsyncStreamIterator(Generic[_T]):
-    def __init__(self, read_func: Callable[[], Awaitable[_T]]) -> None:
-        self.read_func = read_func
-
-    def __aiter__(self) -> "AsyncStreamIterator[_T]":
-        return self
-
-    async def __anext__(self) -> _T:
-        try:
-            rv = await self.read_func()
-        except EofStream:
-            raise StopAsyncIteration
-        if rv == b"":
-            raise StopAsyncIteration
-        return rv
-
-
-class ChunkTupleAsyncStreamIterator:
-    def __init__(self, stream: "StreamReader") -> None:
-        self._stream = stream
-
-    def __aiter__(self) -> "ChunkTupleAsyncStreamIterator":
-        return self
-
-    async def __anext__(self) -> Tuple[bytes, bool]:
-        rv = await self._stream.readchunk()
-        if rv == (b"", False):
-            raise StopAsyncIteration
-        return rv
-
-
-class AsyncStreamReaderMixin:
-    def __aiter__(self) -> AsyncStreamIterator[bytes]:
-        return AsyncStreamIterator(self.readline)  # type: ignore[attr-defined]
-
-    def iter_chunked(self, n: int) -> AsyncStreamIterator[bytes]:
-        """Returns an asynchronous iterator that yields chunks of size n.
-
-        Python-3.5 available for Python 3.5+ only
-        """
-        return AsyncStreamIterator(
-            lambda: self.read(n)  # type: ignore[attr-defined,no-any-return]
-        )
-
-    def iter_any(self) -> AsyncStreamIterator[bytes]:
-        """Yield all available data as soon as it is received.
-
-        Python-3.5 available for Python 3.5+ only
-        """
-        return AsyncStreamIterator(self.readany)  # type: ignore[attr-defined]
-
-    def iter_chunks(self) -> ChunkTupleAsyncStreamIterator:
-        """Yield chunks of data as they are received by the server.
-
-        The yielded objects are tuples
-        of (bytes, bool) as returned by the StreamReader.readchunk method.
-
-        Python-3.5 available for Python 3.5+ only
-        """
-        return ChunkTupleAsyncStreamIterator(self)  # type: ignore[arg-type]
-
-
-class StreamReader(AsyncStreamReaderMixin):
-    """An enhancement of asyncio.StreamReader.
-
-    Supports asynchronous iteration by line, chunk or as available::
-
-        async for line in reader:
-            ...
-        async for chunk in reader.iter_chunked(1024):
-            ...
-        async for slice in reader.iter_any():
-            ...
-
-    """
-
-    total_bytes = 0
-
-    def __init__(
-        self,
-        protocol: BaseProtocol,
-        limit: int,
-        *,
-        timer: Optional[BaseTimerContext] = None,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ) -> None:
-        self._protocol = protocol
-        self._low_water = limit
-        self._high_water = limit * 2
-        if loop is None:
-            loop = asyncio.get_event_loop()
-        self._loop = loop
-        self._size = 0
-        self._cursor = 0
-        self._http_chunk_splits: Optional[List[int]] = None
-        self._buffer: Deque[bytes] = collections.deque()
-        self._buffer_offset = 0
-        self._eof = False
-        self._waiter: Optional[asyncio.Future[None]] = None
-        self._eof_waiter: Optional[asyncio.Future[None]] = None
-        self._exception: Optional[BaseException] = None
-        self._timer = timer
-        self._eof_callbacks: List[Callable[[], None]] = []
-
-    def __repr__(self) -> str:
-        info = [self.__class__.__name__]
-        if self._size:
-            info.append("%d bytes" % self._size)
-        if self._eof:
-            info.append("eof")
-        if self._low_water != 2**16:  # default limit
-            info.append("low=%d high=%d" % (self._low_water, self._high_water))
-        if self._waiter:
-            info.append("w=%r" % self._waiter)
-        if self._exception:
-            info.append("e=%r" % self._exception)
-        return "<%s>" % " ".join(info)
-
-    def get_read_buffer_limits(self) -> Tuple[int, int]:
-        return (self._low_water, self._high_water)
-
-    def exception(self) -> Optional[BaseException]:
-        return self._exception
-
-    def set_exception(self, exc: BaseException) -> None:
-        self._exception = exc
-        self._eof_callbacks.clear()
-
-        waiter = self._waiter
-        if waiter is not None:
-            self._waiter = None
-            set_exception(waiter, exc)
-
-        waiter = self._eof_waiter
-        if waiter is not None:
-            self._eof_waiter = None
-            set_exception(waiter, exc)
-
-    def on_eof(self, callback: Callable[[], None]) -> None:
-        if self._eof:
-            try:
-                callback()
-            except Exception:
-                internal_logger.exception("Exception in eof callback")
-        else:
-            self._eof_callbacks.append(callback)
-
-    def feed_eof(self) -> None:
-        self._eof = True
-
-        waiter = self._waiter
-        if waiter is not None:
-            self._waiter = None
-            set_result(waiter, None)
-
-        waiter = self._eof_waiter
-        if waiter is not None:
-            self._eof_waiter = None
-            set_result(waiter, None)
-
-        for cb in self._eof_callbacks:
-            try:
-                cb()
-            except Exception:
-                internal_logger.exception("Exception in eof callback")
-
-        self._eof_callbacks.clear()
-
-    def is_eof(self) -> bool:
-        """Return True if  'feed_eof' was called."""
-        return self._eof
-
-    def at_eof(self) -> bool:
-        """Return True if the buffer is empty and 'feed_eof' was called."""
-        return self._eof and not self._buffer
-
-    async def wait_eof(self) -> None:
-        if self._eof:
-            return
-
-        assert self._eof_waiter is None
-        self._eof_waiter = self._loop.create_future()
-        try:
-            await self._eof_waiter
-        finally:
-            self._eof_waiter = None
-
-    def unread_data(self, data: bytes) -> None:
-        """rollback reading some data from stream, inserting it to buffer head."""
-        warnings.warn(
-            "unread_data() is deprecated "
-            "and will be removed in future releases (#3260)",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        if not data:
-            return
-
-        if self._buffer_offset:
-            self._buffer[0] = self._buffer[0][self._buffer_offset :]
-            self._buffer_offset = 0
-        self._size += len(data)
-        self._cursor -= len(data)
-        self._buffer.appendleft(data)
-        self._eof_counter = 0
-
-    # TODO: size is ignored, remove the param later
-    def feed_data(self, data: bytes, size: int = 0) -> None:
-        assert not self._eof, "feed_data after feed_eof"
-
-        if not data:
-            return
-
-        self._size += len(data)
-        self._buffer.append(data)
-        self.total_bytes += len(data)
-
-        waiter = self._waiter
-        if waiter is not None:
-            self._waiter = None
-            set_result(waiter, None)
-
-        if self._size > self._high_water and not self._protocol._reading_paused:
-            self._protocol.pause_reading()
-
-    def begin_http_chunk_receiving(self) -> None:
-        if self._http_chunk_splits is None:
-            if self.total_bytes:
-                raise RuntimeError(
-                    "Called begin_http_chunk_receiving when" "some data was already fed"
-                )
-            self._http_chunk_splits = []
-
-    def end_http_chunk_receiving(self) -> None:
-        if self._http_chunk_splits is None:
-            raise RuntimeError(
-                "Called end_chunk_receiving without calling "
-                "begin_chunk_receiving first"
-            )
-
-        # self._http_chunk_splits contains logical byte offsets from start of
-        # the body transfer. Each offset is the offset of the end of a chunk.
-        # "Logical" means bytes, accessible for a user.
-        # If no chunks containig logical data were received, current position
-        # is difinitely zero.
-        pos = self._http_chunk_splits[-1] if self._http_chunk_splits else 0
-
-        if self.total_bytes == pos:
-            # We should not add empty chunks here. So we check for that.
-            # Note, when chunked + gzip is used, we can receive a chunk
-            # of compressed data, but that data may not be enough for gzip FSM
-            # to yield any uncompressed data. That's why current position may
-            # not change after receiving a chunk.
-            return
-
-        self._http_chunk_splits.append(self.total_bytes)
-
-        # wake up readchunk when end of http chunk received
-        waiter = self._waiter
-        if waiter is not None:
-            self._waiter = None
-            set_result(waiter, None)
-
-    async def _wait(self, func_name: str) -> None:
-        # StreamReader uses a future to link the protocol feed_data() method
-        # to a read coroutine. Running two read coroutines at the same time
-        # would have an unexpected behaviour. It would not possible to know
-        # which coroutine would get the next data.
-        if self._waiter is not None:
-            raise RuntimeError(
-                "%s() called while another coroutine is "
-                "already waiting for incoming data" % func_name
-            )
-
-        waiter = self._waiter = self._loop.create_future()
-        try:
-            if self._timer:
-                with self._timer:
-                    await waiter
-            else:
-                await waiter
-        finally:
-            self._waiter = None
-
-    async def readline(self) -> bytes:
-        return await self.readuntil()
-
-    async def readuntil(self, separator: bytes = b"\n") -> bytes:
-        seplen = len(separator)
-        if seplen == 0:
-            raise ValueError("Separator should be at least one-byte string")
-
-        if self._exception is not None:
-            raise self._exception
-
-        chunk = b""
-        chunk_size = 0
-        not_enough = True
-
-        while not_enough:
-            while self._buffer and not_enough:
-                offset = self._buffer_offset
-                ichar = self._buffer[0].find(separator, offset) + 1
-                # Read from current offset to found separator or to the end.
-                data = self._read_nowait_chunk(ichar - offset if ichar else -1)
-                chunk += data
-                chunk_size += len(data)
-                if ichar:
-                    not_enough = False
-
-                if chunk_size > self._high_water:
-                    raise ValueError("Chunk too big")
-
-            if self._eof:
-                break
-
-            if not_enough:
-                await self._wait("readuntil")
-
-        return chunk
-
-    async def read(self, n: int = -1) -> bytes:
-        if self._exception is not None:
-            raise self._exception
-
-        # migration problem; with DataQueue you have to catch
-        # EofStream exception, so common way is to run payload.read() inside
-        # infinite loop. what can cause real infinite loop with StreamReader
-        # lets keep this code one major release.
-        if __debug__:
-            if self._eof and not self._buffer:
-                self._eof_counter = getattr(self, "_eof_counter", 0) + 1
-                if self._eof_counter > 5:
-                    internal_logger.warning(
-                        "Multiple access to StreamReader in eof state, "
-                        "might be infinite loop.",
-                        stack_info=True,
-                    )
-
-        if not n:
-            return b""
-
-        if n < 0:
-            # This used to just loop creating a new waiter hoping to
-            # collect everything in self._buffer, but that would
-            # deadlock if the subprocess sends more than self.limit
-            # bytes.  So just call self.readany() until EOF.
-            blocks = []
-            while True:
-                block = await self.readany()
-                if not block:
-                    break
-                blocks.append(block)
-            return b"".join(blocks)
-
-        # TODO: should be `if` instead of `while`
-        # because waiter maybe triggered on chunk end,
-        # without feeding any data
-        while not self._buffer and not self._eof:
-            await self._wait("read")
-
-        return self._read_nowait(n)
-
-    async def readany(self) -> bytes:
-        if self._exception is not None:
-            raise self._exception
-
-        # TODO: should be `if` instead of `while`
-        # because waiter maybe triggered on chunk end,
-        # without feeding any data
-        while not self._buffer and not self._eof:
-            await self._wait("readany")
-
-        return self._read_nowait(-1)
-
-    async def readchunk(self) -> Tuple[bytes, bool]:
-        """Returns a tuple of (data, end_of_http_chunk).
-
-        When chunked transfer
-        encoding is used, end_of_http_chunk is a boolean indicating if the end
-        of the data corresponds to the end of a HTTP chunk , otherwise it is
-        always False.
-        """
-        while True:
-            if self._exception is not None:
-                raise self._exception
-
-            while self._http_chunk_splits:
-                pos = self._http_chunk_splits.pop(0)
-                if pos == self._cursor:
-                    return (b"", True)
-                if pos > self._cursor:
-                    return (self._read_nowait(pos - self._cursor), True)
-                internal_logger.warning(
-                    "Skipping HTTP chunk end due to data "
-                    "consumption beyond chunk boundary"
-                )
-
-            if self._buffer:
-                return (self._read_nowait_chunk(-1), False)
-                # return (self._read_nowait(-1), False)
-
-            if self._eof:
-                # Special case for signifying EOF.
-                # (b'', True) is not a final return value actually.
-                return (b"", False)
-
-            await self._wait("readchunk")
-
-    async def readexactly(self, n: int) -> bytes:
-        if self._exception is not None:
-            raise self._exception
-
-        blocks: List[bytes] = []
-        while n > 0:
-            block = await self.read(n)
-            if not block:
-                partial = b"".join(blocks)
-                raise asyncio.IncompleteReadError(partial, len(partial) + n)
-            blocks.append(block)
-            n -= len(block)
-
-        return b"".join(blocks)
-
-    def read_nowait(self, n: int = -1) -> bytes:
-        # default was changed to be consistent with .read(-1)
-        #
-        # I believe the most users don't know about the method and
-        # they are not affected.
-        if self._exception is not None:
-            raise self._exception
-
-        if self._waiter and not self._waiter.done():
-            raise RuntimeError(
-                "Called while some coroutine is waiting for incoming data."
-            )
-
-        return self._read_nowait(n)
-
-    def _read_nowait_chunk(self, n: int) -> bytes:
-        first_buffer = self._buffer[0]
-        offset = self._buffer_offset
-        if n != -1 and len(first_buffer) - offset > n:
-            data = first_buffer[offset : offset + n]
-            self._buffer_offset += n
-
-        elif offset:
-            self._buffer.popleft()
-            data = first_buffer[offset:]
-            self._buffer_offset = 0
-
-        else:
-            data = self._buffer.popleft()
-
-        self._size -= len(data)
-        self._cursor += len(data)
-
-        chunk_splits = self._http_chunk_splits
-        # Prevent memory leak: drop useless chunk splits
-        while chunk_splits and chunk_splits[0] < self._cursor:
-            chunk_splits.pop(0)
-
-        if self._size < self._low_water and self._protocol._reading_paused:
-            self._protocol.resume_reading()
-        return data
-
-    def _read_nowait(self, n: int) -> bytes:
-        """Read not more than n bytes, or whole buffer if n == -1"""
-        chunks = []
-
-        while self._buffer:
-            chunk = self._read_nowait_chunk(n)
-            chunks.append(chunk)
-            if n != -1:
-                n -= len(chunk)
-                if n == 0:
-                    break
-
-        return b"".join(chunks) if chunks else b""
-
-
-class EmptyStreamReader(StreamReader):  # lgtm [py/missing-call-to-init]
-    def __init__(self) -> None:
-        pass
-
-    def exception(self) -> Optional[BaseException]:
-        return None
-
-    def set_exception(self, exc: BaseException) -> None:
-        pass
-
-    def on_eof(self, callback: Callable[[], None]) -> None:
-        try:
-            callback()
-        except Exception:
-            internal_logger.exception("Exception in eof callback")
-
-    def feed_eof(self) -> None:
-        pass
-
-    def is_eof(self) -> bool:
-        return True
-
-    def at_eof(self) -> bool:
-        return True
-
-    async def wait_eof(self) -> None:
-        return
-
-    def feed_data(self, data: bytes, n: int = 0) -> None:
-        pass
-
-    async def readline(self) -> bytes:
-        return b""
-
-    async def read(self, n: int = -1) -> bytes:
-        return b""
-
-    # TODO add async def readuntil
-
-    async def readany(self) -> bytes:
-        return b""
-
-    async def readchunk(self) -> Tuple[bytes, bool]:
-        return (b"", True)
-
-    async def readexactly(self, n: int) -> bytes:
-        raise asyncio.IncompleteReadError(b"", n)
-
-    def read_nowait(self, n: int = -1) -> bytes:
-        return b""
-
-
-EMPTY_PAYLOAD: Final[StreamReader] = EmptyStreamReader()
-
-
-class DataQueue(Generic[_T]):
-    """DataQueue is a general-purpose blocking queue with one reader."""
-
-    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
-        self._loop = loop
-        self._eof = False
-        self._waiter: Optional[asyncio.Future[None]] = None
-        self._exception: Optional[BaseException] = None
-        self._size = 0
-        self._buffer: Deque[Tuple[_T, int]] = collections.deque()
-
-    def __len__(self) -> int:
-        return len(self._buffer)
-
-    def is_eof(self) -> bool:
-        return self._eof
-
-    def at_eof(self) -> bool:
-        return self._eof and not self._buffer
-
-    def exception(self) -> Optional[BaseException]:
-        return self._exception
-
-    def set_exception(self, exc: BaseException) -> None:
-        self._eof = True
-        self._exception = exc
-
-        waiter = self._waiter
-        if waiter is not None:
-            self._waiter = None
-            set_exception(waiter, exc)
-
-    def feed_data(self, data: _T, size: int = 0) -> None:
-        self._size += size
-        self._buffer.append((data, size))
-
-        waiter = self._waiter
-        if waiter is not None:
-            self._waiter = None
-            set_result(waiter, None)
-
-    def feed_eof(self) -> None:
-        self._eof = True
-
-        waiter = self._waiter
-        if waiter is not None:
-            self._waiter = None
-            set_result(waiter, None)
-
-    async def read(self) -> _T:
-        if not self._buffer and not self._eof:
-            assert not self._waiter
-            self._waiter = self._loop.create_future()
-            try:
-                await self._waiter
-            except (asyncio.CancelledError, asyncio.TimeoutError):
-                self._waiter = None
-                raise
-
-        if self._buffer:
-            data, size = self._buffer.popleft()
-            self._size -= size
-            return data
-        else:
-            if self._exception is not None:
-                raise self._exception
-            else:
-                raise EofStream
-
-    def __aiter__(self) -> AsyncStreamIterator[_T]:
-        return AsyncStreamIterator(self.read)
-
-
-class FlowControlDataQueue(DataQueue[_T]):
-    """FlowControlDataQueue resumes and pauses an underlying stream.
-
-    It is a destination for parsed data.
-    """
-
-    def __init__(
-        self, protocol: BaseProtocol, limit: int, *, loop: asyncio.AbstractEventLoop
-    ) -> None:
-        super().__init__(loop=loop)
-
-        self._protocol = protocol
-        self._limit = limit * 2
-
-    def feed_data(self, data: _T, size: int = 0) -> None:
-        super().feed_data(data, size)
-
-        if self._size > self._limit and not self._protocol._reading_paused:
-            self._protocol.pause_reading()
-
-    async def read(self) -> _T:
-        try:
-            return await super().read()
-        finally:
-            if self._size < self._limit and self._protocol._reading_paused:
-                self._protocol.resume_reading()
diff --git a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/cu2qu/benchmark.py b/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/cu2qu/benchmark.py
deleted file mode 100644
index 2ab1e966b1745b868518f46087cc562e11026822..0000000000000000000000000000000000000000
--- a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/cu2qu/benchmark.py
+++ /dev/null
@@ -1,55 +0,0 @@
-"""Benchmark the cu2qu algorithm performance."""
-
-from .cu2qu import *
-import random
-import timeit
-
-MAX_ERR = 0.05
-
-
-def generate_curve():
-    return [
-        tuple(float(random.randint(0, 2048)) for coord in range(2))
-        for point in range(4)
-    ]
-
-
-def setup_curve_to_quadratic():
-    return generate_curve(), MAX_ERR
-
-
-def setup_curves_to_quadratic():
-    num_curves = 3
-    return ([generate_curve() for curve in range(num_curves)], [MAX_ERR] * num_curves)
-
-
-def run_benchmark(module, function, setup_suffix="", repeat=5, number=1000):
-    setup_func = "setup_" + function
-    if setup_suffix:
-        print("%s with %s:" % (function, setup_suffix), end="")
-        setup_func += "_" + setup_suffix
-    else:
-        print("%s:" % function, end="")
-
-    def wrapper(function, setup_func):
-        function = globals()[function]
-        setup_func = globals()[setup_func]
-
-        def wrapped():
-            return function(*setup_func())
-
-        return wrapped
-
-    results = timeit.repeat(wrapper(function, setup_func), repeat=repeat, number=number)
-    print("\t%5.1fus" % (min(results) * 1000000.0 / number))
-
-
-def main():
-    """Benchmark the cu2qu algorithm performance."""
-    run_benchmark("cu2qu", "curve_to_quadratic")
-    run_benchmark("cu2qu", "curves_to_quadratic")
-
-
-if __name__ == "__main__":
-    random.seed(1)
-    main()
diff --git a/spaces/cmtry/nAIr/README.md b/spaces/cmtry/nAIr/README.md
deleted file mode 100644
index 9537e10b867729c9e2bcf4313cf222f3ac414a72..0000000000000000000000000000000000000000
--- a/spaces/cmtry/nAIr/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: nAIr, tumo project
-emoji: 🔥
-colorFrom: yellow
-colorTo: gray
-sdk: gradio
-sdk_version: 3.44.4
-app_file: app.py
-pinned: false
-license: mit
----
-
-Prodia's Stable Diffusion Space.
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/ac3.h b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/ac3.h
deleted file mode 100644
index 2386c15ad00a3065a653d4028080c792394e64ed..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/ac3.h
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Common code between the AC-3 encoder and decoder
- * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Common code between the AC-3 encoder and decoder.
- */
-
-#ifndef AVCODEC_AC3_H
-#define AVCODEC_AC3_H
-
-#include <math.h>
-#include <stdint.h>
-
-#include "ac3tab.h"
-
-#ifndef USE_FIXED
-#define USE_FIXED 0
-#endif
-
-#if USE_FIXED
-
-#define FIXR(a)                 ((int)((a) * 0 + 0.5))
-#define FIXR12(a)               ((int)((a) * 4096 + 0.5))
-#define FIXR15(a)               ((int)((a) * 32768 + 0.5))
-#define ROUND15(x)              ((x) + 16384) >> 15
-
-#define AC3_RENAME(x)           x ## _fixed
-#define AC3_NORM(norm)          (1<<24)/(norm)
-#define AC3_MUL(a,b)            ((((int64_t) (a)) * (b))>>12)
-#define AC3_RANGE(x)            ((x)|(((x)&128)<<1))
-#define AC3_HEAVY_RANGE(x)      ((x)<<1)
-#define AC3_DYNAMIC_RANGE(x)    (x)
-#define AC3_SPX_BLEND(x)        (x)
-#define AC3_DYNAMIC_RANGE1      0
-
-typedef int                     INTFLOAT;
-typedef unsigned int            UINTFLOAT;
-typedef int16_t                 SHORTFLOAT;
-
-#else /* USE_FIXED */
-#include "libavutil/libm.h"
-
-#define FIXR(x)                 ((float)(x))
-#define FIXR12(x)               ((float)(x))
-#define FIXR15(x)               ((float)(x))
-#define ROUND15(x)              (x)
-
-#define AC3_RENAME(x)           x
-#define AC3_NORM(norm)          (1.0f/(norm))
-#define AC3_MUL(a,b)            ((a) * (b))
-#define AC3_RANGE(x)            (dynamic_range_tab[(x)])
-#define AC3_HEAVY_RANGE(x)      (ff_ac3_heavy_dynamic_range_tab[(x)])
-#define AC3_DYNAMIC_RANGE(x)    (powf(x,  s->drc_scale))
-#define AC3_SPX_BLEND(x)        (x)* (1.0f/32)
-#define AC3_DYNAMIC_RANGE1      1.0f
-
-typedef float                   INTFLOAT;
-typedef float                   UINTFLOAT;
-typedef float                   SHORTFLOAT;
-
-#endif /* USE_FIXED */
-
-#define AC3_LEVEL(x)            ROUND15((x) * FIXR15(M_SQRT1_2))
-
-/* pre-defined gain values */
-#define LEVEL_PLUS_3DB          M_SQRT2
-#define LEVEL_PLUS_1POINT5DB    1.1892071150027209
-#define LEVEL_MINUS_1POINT5DB   0.8408964152537145
-#define LEVEL_MINUS_3DB         M_SQRT1_2
-#define LEVEL_MINUS_4POINT5DB   0.5946035575013605
-#define LEVEL_MINUS_6DB         0.5000000000000000
-#define LEVEL_MINUS_9DB         0.3535533905932738
-#define LEVEL_ZERO              0.0000000000000000
-#define LEVEL_ONE               1.0000000000000000
-
-typedef struct AC3BitAllocParameters {
-    int sr_code;
-    int sr_shift;
-    int slow_gain, slow_decay, fast_decay, db_per_bit, floor;
-    int cpl_fast_leak, cpl_slow_leak;
-} AC3BitAllocParameters;
-
-/**
- * Calculate the log power-spectral density of the input signal.
- * This gives a rough estimate of signal power in the frequency domain by using
- * the spectral envelope (exponents).  The psd is also separately grouped
- * into critical bands for use in the calculating the masking curve.
- * 128 units in psd = -6 dB.  The dbknee parameter in AC3BitAllocParameters
- * determines the reference level.
- *
- * @param[in]  exp        frequency coefficient exponents
- * @param[in]  start      starting bin location
- * @param[in]  end        ending bin location
- * @param[out] psd        signal power for each frequency bin
- * @param[out] band_psd   signal power for each critical band
- */
-void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd,
-                               int16_t *band_psd);
-
-/**
- * Calculate the masking curve.
- * First, the excitation is calculated using parameters in s and the signal
- * power in each critical band.  The excitation is compared with a predefined
- * hearing threshold table to produce the masking curve.  If delta bit
- * allocation information is provided, it is used for adjusting the masking
- * curve, usually to give a closer match to a better psychoacoustic model.
- *
- * @param[in]  s            adjustable bit allocation parameters
- * @param[in]  band_psd     signal power for each critical band
- * @param[in]  start        starting bin location
- * @param[in]  end          ending bin location
- * @param[in]  fast_gain    fast gain (estimated signal-to-mask ratio)
- * @param[in]  is_lfe       whether or not the channel being processed is the LFE
- * @param[in]  dba_mode     delta bit allocation mode (none, reuse, or new)
- * @param[in]  dba_nsegs    number of delta segments
- * @param[in]  dba_offsets  location offsets for each segment
- * @param[in]  dba_lengths  length of each segment
- * @param[in]  dba_values   delta bit allocation for each segment
- * @param[out] mask         calculated masking curve
- * @return returns 0 for success, non-zero for error
- */
-int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd,
-                               int start, int end, int fast_gain, int is_lfe,
-                               int dba_mode, int dba_nsegs, uint8_t *dba_offsets,
-                               uint8_t *dba_lengths, uint8_t *dba_values,
-                               int16_t *mask);
-
-#endif /* AVCODEC_AC3_H */
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/adpcm_data.h b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/adpcm_data.h
deleted file mode 100644
index 7dec6499f86186f185e74bf514e2e01bc7b8e4b5..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/adpcm_data.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2001-2003 The FFmpeg project
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * ADPCM tables
- */
-
-#ifndef AVCODEC_ADPCM_DATA_H
-#define AVCODEC_ADPCM_DATA_H
-
-#include <stdint.h>
-
-static const uint8_t ff_adpcm_ima_block_sizes[4]   = {  4, 12, 4, 20 };
-static const uint8_t ff_adpcm_ima_block_samples[4] = { 16, 32, 8, 32 };
-
-extern const int8_t  ff_adpcm_index_table[16];
-extern const int16_t ff_adpcm_step_table[89];
-extern const int16_t ff_adpcm_AdaptationTable[];
-extern const uint8_t ff_adpcm_AdaptCoeff1[];
-extern const int8_t  ff_adpcm_AdaptCoeff2[];
-extern const int16_t ff_adpcm_yamaha_indexscale[];
-extern const int8_t  ff_adpcm_yamaha_difflookup[];
-
-#endif /* AVCODEC_ADPCM_DATA_H */
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/flashsv2enc.c b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/flashsv2enc.c
deleted file mode 100644
index 75b48eb1fd3178ce9c8dede6d3116e9c0f4bdc07..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/flashsv2enc.c
+++ /dev/null
@@ -1,925 +0,0 @@
-/*
- * Flash Screen Video Version 2 encoder
- * Copyright (C) 2009 Joshua Warner
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Flash Screen Video Version 2 encoder
- * @author Joshua Warner
- */
-
-/* Differences from version 1 stream:
- * NOTE: Currently, the only player that supports version 2 streams is Adobe Flash Player itself.
- * * Supports sending only a range of scanlines in a block,
- *   indicating a difference from the corresponding block in the last keyframe.
- * * Supports initializing the zlib dictionary with data from the corresponding
- *   block in the last keyframe, to improve compression.
- * * Supports a hybrid 15-bit rgb / 7-bit palette color space.
- */
-
-/* TODO:
- * Don't keep Block structures for both current frame and keyframe.
- * Make better heuristics for deciding stream parameters (optimum_* functions).  Currently these return constants.
- * Figure out how to encode palette information in the stream, choose an optimum palette at each keyframe.
- * Figure out how the zlibPrimeCompressCurrent flag works, implement support.
- * Find other sample files (that weren't generated here), develop a decoder.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <zlib.h>
-
-#include "libavutil/imgutils.h"
-#include "avcodec.h"
-#include "codec_internal.h"
-#include "encode.h"
-#include "put_bits.h"
-#include "bytestream.h"
-#include "zlib_wrapper.h"
-
-#define HAS_IFRAME_IMAGE 0x02
-#define HAS_PALLET_INFO 0x01
-
-#define COLORSPACE_BGR 0x00
-#define COLORSPACE_15_7 0x10
-#define HAS_DIFF_BLOCKS 0x04
-#define ZLIB_PRIME_COMPRESS_CURRENT 0x02
-#define ZLIB_PRIME_COMPRESS_PREVIOUS 0x01
-
-// Disables experimental "smart" parameter-choosing code, as well as the statistics that it depends on.
-// At the moment, the "smart" code is a great example of how the parameters *shouldn't* be chosen.
-#define FLASHSV2_DUMB
-
-typedef struct Block {
-    uint8_t *enc;
-    uint8_t *sl_begin, *sl_end;
-    int enc_size;
-    uint8_t *data;
-    unsigned long data_size;
-
-    uint8_t start, len;
-    uint8_t dirty;
-    uint8_t col, row, width, height;
-    uint8_t flags;
-} Block;
-
-typedef struct Palette {
-    unsigned colors[128];
-    uint8_t index[1 << 15];
-} Palette;
-
-typedef struct FlashSV2Context {
-    AVCodecContext *avctx;
-    uint8_t *current_frame;
-    uint8_t *key_frame;
-    uint8_t *encbuffer;
-    uint8_t *keybuffer;
-    uint8_t *databuffer;
-
-    uint8_t *blockbuffer;
-    int blockbuffer_size;
-
-    Block *frame_blocks;
-    Block *key_blocks;
-    int frame_size;
-    int blocks_size;
-
-    int use15_7, dist, comp;
-
-    int rows, cols;
-
-    int64_t last_key_frame;
-
-    int image_width, image_height;
-    int block_width, block_height;
-    uint8_t flags;
-    uint8_t use_custom_palette;
-    uint8_t palette_type;       ///< 0=>default, 1=>custom - changed when palette regenerated.
-    Palette palette;
-    FFZStream zstream;
-#ifndef FLASHSV2_DUMB
-    double tot_blocks;          ///< blocks encoded since last keyframe
-    double diff_blocks;         ///< blocks that were different since last keyframe
-    double tot_lines;           ///< total scanlines in image since last keyframe
-    double diff_lines;          ///< scanlines that were different since last keyframe
-    double raw_size;            ///< size of raw frames since last keyframe
-    double comp_size;           ///< size of compressed data since last keyframe
-    double uncomp_size;         ///< size of uncompressed data since last keyframe
-
-    double total_bits;          ///< total bits written to stream so far
-#endif
-} FlashSV2Context;
-
-static av_cold void cleanup(FlashSV2Context * s)
-{
-    av_freep(&s->encbuffer);
-    av_freep(&s->keybuffer);
-    av_freep(&s->databuffer);
-    av_freep(&s->blockbuffer);
-    av_freep(&s->current_frame);
-    av_freep(&s->key_frame);
-
-    av_freep(&s->frame_blocks);
-    av_freep(&s->key_blocks);
-    ff_deflate_end(&s->zstream);
-}
-
-static void init_blocks(FlashSV2Context * s, Block * blocks,
-                        uint8_t * encbuf, uint8_t * databuf)
-{
-    int row, col;
-    Block *b;
-    memset(blocks, 0, s->cols * s->rows * sizeof(*blocks));
-    for (col = 0; col < s->cols; col++) {
-        for (row = 0; row < s->rows; row++) {
-            b = blocks + (col + row * s->cols);
-            b->width = (col < s->cols - 1) ?
-                s->block_width :
-                s->image_width - col * s->block_width;
-
-            b->height = (row < s->rows - 1) ?
-                s->block_height :
-                s->image_height - row * s->block_height;
-
-            b->row   = row;
-            b->col   = col;
-            b->enc   = encbuf;
-            b->data  = databuf;
-            encbuf  += b->width * b->height * 3;
-            databuf  = databuf ? databuf + b->width * b->height * 6 : NULL;
-        }
-    }
-}
-
-static void reset_stats(FlashSV2Context * s)
-{
-#ifndef FLASHSV2_DUMB
-    s->diff_blocks = 0.1;
-    s->tot_blocks = 1;
-    s->diff_lines = 0.1;
-    s->tot_lines = 1;
-    s->raw_size = s->comp_size = s->uncomp_size = 10;
-#endif
-}
-
-static int update_block_dimensions(FlashSV2Context *s, int block_width, int block_height)
-{
-    s->block_width  = block_width;
-    s->block_height = block_height;
-    s->rows = (s->image_height + s->block_height - 1) / s->block_height;
-    s->cols = (s->image_width  + s->block_width  - 1) / s->block_width;
-    if (s->rows * s->cols > s->blocks_size / sizeof(Block)) {
-        s->frame_blocks = av_realloc_array(s->frame_blocks, s->rows, s->cols * sizeof(Block));
-        s->key_blocks = av_realloc_array(s->key_blocks, s->cols, s->rows * sizeof(Block));
-        if (!s->frame_blocks || !s->key_blocks) {
-            av_log(s->avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
-            return AVERROR(ENOMEM);
-        }
-        s->blocks_size = s->rows * s->cols * sizeof(Block);
-    }
-    init_blocks(s, s->frame_blocks, s->encbuffer, s->databuffer);
-    init_blocks(s, s->key_blocks, s->keybuffer, 0);
-
-    av_fast_malloc(&s->blockbuffer, &s->blockbuffer_size, block_width * block_height * 6);
-    if (!s->blockbuffer) {
-        av_log(s->avctx, AV_LOG_ERROR, "Could not allocate block buffer.\n");
-        return AVERROR(ENOMEM);
-    }
-    return 0;
-}
-
-
-static av_cold int flashsv2_encode_init(AVCodecContext * avctx)
-{
-    FlashSV2Context *s = avctx->priv_data;
-    int ret;
-
-    s->avctx = avctx;
-
-    s->comp = avctx->compression_level;
-    if (s->comp == -1)
-        s->comp = 9;
-    if (s->comp < 0 || s->comp > 9) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Compression level should be 0-9, not %d\n", s->comp);
-        return AVERROR(EINVAL);
-    }
-
-
-    if ((avctx->width > 4095) || (avctx->height > 4095)) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Input dimensions too large, input must be max 4095x4095 !\n");
-        return AVERROR(EINVAL);
-    }
-    if ((avctx->width < 16) || (avctx->height < 16)) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Input dimensions too small, input must be at least 16x16 !\n");
-        return AVERROR(EINVAL);
-    }
-
-    if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
-        return ret;
-
-    ret = ff_deflate_init(&s->zstream, s->comp, avctx);
-    if (ret < 0)
-        return ret;
-    s->last_key_frame = 0;
-
-    s->image_width  = avctx->width;
-    s->image_height = avctx->height;
-
-    s->frame_size  = s->image_width * s->image_height * 3;
-
-    s->encbuffer     = av_mallocz(s->frame_size);
-    s->keybuffer     = av_mallocz(s->frame_size);
-    s->databuffer    = av_mallocz(s->frame_size * 6);
-    s->current_frame = av_mallocz(s->frame_size);
-    s->key_frame     = av_mallocz(s->frame_size);
-    if (!s->encbuffer || !s->keybuffer || !s->databuffer
-        || !s->current_frame || !s->key_frame) {
-        av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
-        return AVERROR(ENOMEM);
-    }
-
-    reset_stats(s);
-#ifndef FLASHSV2_DUMB
-    s->total_bits = 1;
-#endif
-
-    s->use_custom_palette =  0;
-    s->palette_type       = -1;        // so that the palette will be generated in reconfigure_at_keyframe
-
-    return update_block_dimensions(s, 64, 64);
-}
-
-static int new_key_frame(FlashSV2Context * s)
-{
-    int i;
-    memcpy(s->key_blocks, s->frame_blocks, s->blocks_size);
-    memcpy(s->key_frame, s->current_frame, s->frame_size);
-
-    for (i = 0; i < s->rows * s->cols; i++) {
-        s->key_blocks[i].enc += (s->keybuffer - s->encbuffer);
-        s->key_blocks[i].sl_begin = 0;
-        s->key_blocks[i].sl_end   = 0;
-        s->key_blocks[i].data     = 0;
-    }
-    memcpy(s->keybuffer, s->encbuffer, s->frame_size);
-
-    return 0;
-}
-
-static int write_palette(FlashSV2Context * s, uint8_t * buf, int buf_size)
-{
-    //this isn't implemented yet!  Default palette only!
-    return -1;
-}
-
-static int write_header(FlashSV2Context * s, uint8_t * buf, int buf_size)
-{
-    PutBitContext pb;
-    int buf_pos, len;
-
-    if (buf_size < 5)
-        return -1;
-
-    init_put_bits(&pb, buf, buf_size);
-
-    put_bits(&pb, 4, (s->block_width  >> 4) - 1);
-    put_bits(&pb, 12, s->image_width);
-    put_bits(&pb, 4, (s->block_height >> 4) - 1);
-    put_bits(&pb, 12, s->image_height);
-
-    flush_put_bits(&pb);
-    buf_pos = 4;
-
-    buf[buf_pos++] = s->flags;
-
-    if (s->flags & HAS_PALLET_INFO) {
-        len = write_palette(s, buf + buf_pos, buf_size - buf_pos);
-        if (len < 0)
-            return -1;
-        buf_pos += len;
-    }
-
-    return buf_pos;
-}
-
-static int write_block(Block * b, uint8_t * buf, int buf_size)
-{
-    int buf_pos = 0;
-    unsigned block_size = b->data_size;
-
-    if (b->flags & HAS_DIFF_BLOCKS)
-        block_size += 2;
-    if (b->flags & ZLIB_PRIME_COMPRESS_CURRENT)
-        block_size += 2;
-    if (block_size > 0)
-        block_size += 1;
-    if (buf_size < block_size + 2)
-        return -1;
-
-    buf[buf_pos++] = block_size >> 8;
-    buf[buf_pos++] = block_size;
-
-    if (block_size == 0)
-        return buf_pos;
-
-    buf[buf_pos++] = b->flags;
-
-    if (b->flags & HAS_DIFF_BLOCKS) {
-        buf[buf_pos++] = (b->start);
-        buf[buf_pos++] = (b->len);
-    }
-
-    if (b->flags & ZLIB_PRIME_COMPRESS_CURRENT) {
-        //This feature of the format is poorly understood, and as of now, unused.
-        buf[buf_pos++] = (b->col);
-        buf[buf_pos++] = (b->row);
-    }
-
-    memcpy(buf + buf_pos, b->data, b->data_size);
-
-    buf_pos += b->data_size;
-
-    return buf_pos;
-}
-
-static int encode_zlib(Block *b, uint8_t *buf, unsigned long *buf_size,
-                       z_stream *zstream)
-{
-    int res;
-
-    if (deflateReset(zstream) != Z_OK)
-        return AVERROR_EXTERNAL;
-    zstream->next_out  = buf;
-    zstream->avail_out = *buf_size;
-    zstream->next_in   = b->sl_begin;
-    zstream->avail_in  = b->sl_end - b->sl_begin;
-    res = deflate(zstream, Z_FINISH);
-    if (res != Z_STREAM_END)
-        return AVERROR_EXTERNAL;
-    *buf_size -= zstream->avail_out;
-    return 0;
-}
-
-static int encode_zlibprime(Block * b, Block * prime, uint8_t * buf,
-                            int *buf_size, z_stream *zstream)
-{
-    int res;
-
-    if (deflateReset(zstream) != Z_OK)
-        return AVERROR_EXTERNAL;
-    zstream->next_in  = prime->enc;
-    zstream->avail_in = prime->enc_size;
-    while (zstream->avail_in > 0) {
-        zstream->next_out  = buf;
-        zstream->avail_out = *buf_size;
-        res = deflate(zstream, Z_SYNC_FLUSH);
-        if (res < 0)
-            return -1;
-    }
-
-    zstream->next_in   = b->sl_begin;
-    zstream->avail_in  = b->sl_end - b->sl_begin;
-    zstream->next_out  = buf;
-    zstream->avail_out = *buf_size;
-    res = deflate(zstream, Z_FINISH);
-    *buf_size -= zstream->avail_out;
-    if (res != Z_STREAM_END)
-        return -1;
-    return 0;
-}
-
-static int encode_bgr(Block * b, const uint8_t * src, int stride)
-{
-    int i;
-    uint8_t *ptr = b->enc;
-    for (i = 0; i < b->start; i++)
-        memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
-    b->sl_begin = ptr + i * b->width * 3;
-    for (; i < b->start + b->len; i++)
-        memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
-    b->sl_end = ptr + i * b->width * 3;
-    for (; i < b->height; i++)
-        memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
-    b->enc_size = ptr + i * b->width * 3 - b->enc;
-    return b->enc_size;
-}
-
-static inline unsigned pixel_color15(const uint8_t * src)
-{
-    return (src[0] >> 3) | ((src[1] & 0xf8) << 2) | ((src[2] & 0xf8) << 7);
-}
-
-static inline unsigned int chroma_diff(unsigned int c1, unsigned int c2)
-{
-#define ABSDIFF(a,b) (abs((int)(a)-(int)(b)))
-
-    unsigned int t1 = (c1 & 0x000000ff) + ((c1 & 0x0000ff00) >> 8) + ((c1 & 0x00ff0000) >> 16);
-    unsigned int t2 = (c2 & 0x000000ff) + ((c2 & 0x0000ff00) >> 8) + ((c2 & 0x00ff0000) >> 16);
-
-    return ABSDIFF(t1, t2) + ABSDIFF(c1 & 0x000000ff, c2 & 0x000000ff) +
-        ABSDIFF((c1 & 0x0000ff00) >> 8 , (c2 & 0x0000ff00) >> 8) +
-        ABSDIFF((c1 & 0x00ff0000) >> 16, (c2 & 0x00ff0000) >> 16);
-}
-
-static inline int pixel_color7_fast(Palette * palette, unsigned c15)
-{
-    return palette->index[c15];
-}
-
-static int pixel_color7_slow(Palette * palette, unsigned color)
-{
-    int i, min = 0x7fffffff;
-    int minc = -1;
-    for (i = 0; i < 128; i++) {
-        int c1 = palette->colors[i];
-        int diff = chroma_diff(c1, color);
-        if (diff < min) {
-            min = diff;
-            minc = i;
-        }
-    }
-    return minc;
-}
-
-static inline unsigned pixel_bgr(const uint8_t * src)
-{
-    return (src[0]) | (src[1] << 8) | (src[2] << 16);
-}
-
-static int write_pixel_15_7(Palette * palette, uint8_t * dest, const uint8_t * src,
-                            int dist)
-{
-    unsigned c15 = pixel_color15(src);
-    unsigned color = pixel_bgr(src);
-    int d15 = chroma_diff(color, color & 0x00f8f8f8);
-    int c7 = pixel_color7_fast(palette, c15);
-    int d7 = chroma_diff(color, palette->colors[c7]);
-    if (dist + d15 >= d7) {
-        dest[0] = c7;
-        return 1;
-    } else {
-        dest[0] = 0x80 | (c15 >> 8);
-        dest[1] = c15 & 0xff;
-        return 2;
-    }
-}
-
-static int update_palette_index(Palette * palette)
-{
-    int r, g, b;
-    unsigned int bgr, c15, index;
-    for (r = 4; r < 256; r += 8) {
-        for (g = 4; g < 256; g += 8) {
-            for (b = 4; b < 256; b += 8) {
-                bgr = b | (g << 8) | (r << 16);
-                c15 = (b >> 3) | ((g & 0xf8) << 2) | ((r & 0xf8) << 7);
-                index = pixel_color7_slow(palette, bgr);
-
-                palette->index[c15] = index;
-            }
-        }
-    }
-    return 0;
-}
-
-static const unsigned int default_screen_video_v2_palette[128] = {
-    0x00000000, 0x00333333, 0x00666666, 0x00999999, 0x00CCCCCC, 0x00FFFFFF,
-    0x00330000, 0x00660000, 0x00990000, 0x00CC0000, 0x00FF0000, 0x00003300,
-    0x00006600, 0x00009900, 0x0000CC00, 0x0000FF00, 0x00000033, 0x00000066,
-    0x00000099, 0x000000CC, 0x000000FF, 0x00333300, 0x00666600, 0x00999900,
-    0x00CCCC00, 0x00FFFF00, 0x00003333, 0x00006666, 0x00009999, 0x0000CCCC,
-    0x0000FFFF, 0x00330033, 0x00660066, 0x00990099, 0x00CC00CC, 0x00FF00FF,
-    0x00FFFF33, 0x00FFFF66, 0x00FFFF99, 0x00FFFFCC, 0x00FF33FF, 0x00FF66FF,
-    0x00FF99FF, 0x00FFCCFF, 0x0033FFFF, 0x0066FFFF, 0x0099FFFF, 0x00CCFFFF,
-    0x00CCCC33, 0x00CCCC66, 0x00CCCC99, 0x00CCCCFF, 0x00CC33CC, 0x00CC66CC,
-    0x00CC99CC, 0x00CCFFCC, 0x0033CCCC, 0x0066CCCC, 0x0099CCCC, 0x00FFCCCC,
-    0x00999933, 0x00999966, 0x009999CC, 0x009999FF, 0x00993399, 0x00996699,
-    0x0099CC99, 0x0099FF99, 0x00339999, 0x00669999, 0x00CC9999, 0x00FF9999,
-    0x00666633, 0x00666699, 0x006666CC, 0x006666FF, 0x00663366, 0x00669966,
-    0x0066CC66, 0x0066FF66, 0x00336666, 0x00996666, 0x00CC6666, 0x00FF6666,
-    0x00333366, 0x00333399, 0x003333CC, 0x003333FF, 0x00336633, 0x00339933,
-    0x0033CC33, 0x0033FF33, 0x00663333, 0x00993333, 0x00CC3333, 0x00FF3333,
-    0x00003366, 0x00336600, 0x00660033, 0x00006633, 0x00330066, 0x00663300,
-    0x00336699, 0x00669933, 0x00993366, 0x00339966, 0x00663399, 0x00996633,
-    0x006699CC, 0x0099CC66, 0x00CC6699, 0x0066CC99, 0x009966CC, 0x00CC9966,
-    0x0099CCFF, 0x00CCFF99, 0x00FF99CC, 0x0099FFCC, 0x00CC99FF, 0x00FFCC99,
-    0x00111111, 0x00222222, 0x00444444, 0x00555555, 0x00AAAAAA, 0x00BBBBBB,
-    0x00DDDDDD, 0x00EEEEEE
-};
-
-static int generate_default_palette(Palette * palette)
-{
-    memcpy(palette->colors, default_screen_video_v2_palette,
-           sizeof(default_screen_video_v2_palette));
-
-    return update_palette_index(palette);
-}
-
-static int generate_optimum_palette(Palette * palette, const uint8_t * image,
-                                   int width, int height, int stride)
-{
-    //this isn't implemented yet!  Default palette only!
-    return -1;
-}
-
-static inline int encode_15_7_sl(Palette * palette, uint8_t * dest,
-                                 const uint8_t * src, int width, int dist)
-{
-    int len = 0, x;
-    for (x = 0; x < width; x++) {
-        len += write_pixel_15_7(palette, dest + len, src + 3 * x, dist);
-    }
-    return len;
-}
-
-static int encode_15_7(Palette * palette, Block * b, const uint8_t * src,
-                       int stride, int dist)
-{
-    int i;
-    uint8_t *ptr = b->enc;
-    for (i = 0; i < b->start; i++)
-        ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
-    b->sl_begin = ptr;
-    for (; i < b->start + b->len; i++)
-        ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
-    b->sl_end = ptr;
-    for (; i < b->height; i++)
-        ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
-    b->enc_size = ptr - b->enc;
-    return b->enc_size;
-}
-
-static int encode_block(FlashSV2Context *s, Palette * palette, Block * b,
-                        Block *prev, const uint8_t *src, int stride,
-                        int dist, int keyframe)
-{
-    unsigned buf_size = b->width * b->height * 6;
-    uint8_t *buf = s->blockbuffer;
-    int res;
-
-    if (b->flags & COLORSPACE_15_7) {
-        encode_15_7(palette, b, src, stride, dist);
-    } else {
-        encode_bgr(b, src, stride);
-    }
-
-    if (b->len > 0) {
-        b->data_size = buf_size;
-        res = encode_zlib(b, b->data, &b->data_size, &s->zstream.zstream);
-        if (res)
-            return res;
-
-        if (!keyframe) {
-            res = encode_zlibprime(b, prev, buf, &buf_size, &s->zstream.zstream);
-            if (res)
-                return res;
-
-            if (buf_size < b->data_size) {
-                b->data_size = buf_size;
-                memcpy(b->data, buf, buf_size);
-                b->flags |= ZLIB_PRIME_COMPRESS_PREVIOUS;
-            }
-        }
-    } else {
-        b->data_size = 0;
-    }
-    return 0;
-}
-
-static int compare_sl(FlashSV2Context * s, Block * b, const uint8_t * src,
-                      uint8_t * frame, uint8_t * key, int y, int keyframe)
-{
-    if (memcmp(src, frame, b->width * 3) != 0) {
-        b->dirty = 1;
-        memcpy(frame, src, b->width * 3);
-#ifndef FLASHSV2_DUMB
-        s->diff_lines++;
-#endif
-    }
-    if (memcmp(src, key, b->width * 3) != 0) {
-        if (b->len == 0)
-            b->start = y;
-        b->len = y + 1 - b->start;
-    }
-    return 0;
-}
-
-static int mark_all_blocks(FlashSV2Context * s, const uint8_t * src, int stride,
-                           int keyframe)
-{
-    int sl, rsl, col, pos, possl;
-    Block *b;
-    for (sl = s->image_height - 1; sl >= 0; sl--) {
-        for (col = 0; col < s->cols; col++) {
-            rsl = s->image_height - sl - 1;
-            b = s->frame_blocks + col + rsl / s->block_height * s->cols;
-            possl = stride * sl + col * s->block_width * 3;
-            pos = s->image_width * rsl * 3 + col * s->block_width * 3;
-            compare_sl(s, b, src + possl, s->current_frame + pos,
-                       s->key_frame + pos, rsl % s->block_height, keyframe);
-        }
-    }
-#ifndef FLASHSV2_DUMB
-    s->tot_lines += s->image_height * s->cols;
-#endif
-    return 0;
-}
-
-static int encode_all_blocks(FlashSV2Context * s, int keyframe)
-{
-    int row, col, res;
-    uint8_t *data;
-    Block *b, *prev;
-    for (row = 0; row < s->rows; row++) {
-        for (col = 0; col < s->cols; col++) {
-            b = s->frame_blocks + (row * s->cols + col);
-            prev = s->key_blocks + (row * s->cols + col);
-            b->flags = s->use15_7 ? COLORSPACE_15_7 : 0;
-            if (keyframe) {
-                b->start = 0;
-                b->len = b->height;
-            } else if (!b->dirty) {
-                b->start = 0;
-                b->len = 0;
-                b->data_size = 0;
-                continue;
-            } else if (b->start != 0 || b->len != b->height) {
-                b->flags |= HAS_DIFF_BLOCKS;
-            }
-            data = s->current_frame + s->image_width * 3 * s->block_height * row + s->block_width * col * 3;
-            res = encode_block(s, &s->palette, b, prev, data,
-                               s->image_width * 3, s->dist, keyframe);
-#ifndef FLASHSV2_DUMB
-            if (b->dirty)
-                s->diff_blocks++;
-            s->comp_size += b->data_size;
-            s->uncomp_size += b->enc_size;
-#endif
-            if (res)
-                return res;
-        }
-    }
-#ifndef FLASHSV2_DUMB
-    s->raw_size += s->image_width * s->image_height * 3;
-    s->tot_blocks += s->rows * s->cols;
-#endif
-    return 0;
-}
-
-static int write_all_blocks(FlashSV2Context * s, uint8_t * buf,
-                            int buf_size)
-{
-    int row, col, buf_pos = 0, len;
-    Block *b;
-    for (row = 0; row < s->rows; row++) {
-        for (col = 0; col < s->cols; col++) {
-            b = s->frame_blocks + row * s->cols + col;
-            len = write_block(b, buf + buf_pos, buf_size - buf_pos);
-            b->start = b->len = b->dirty = 0;
-            if (len < 0)
-                return len;
-            buf_pos += len;
-        }
-    }
-    return buf_pos;
-}
-
-static int write_bitstream(FlashSV2Context * s, const uint8_t * src, int stride,
-                           uint8_t * buf, int buf_size, int keyframe)
-{
-    int buf_pos, res;
-
-    res = mark_all_blocks(s, src, stride, keyframe);
-    if (res)
-        return res;
-    res = encode_all_blocks(s, keyframe);
-    if (res)
-        return res;
-
-    res = write_header(s, buf, buf_size);
-    if (res < 0) {
-        return res;
-    } else {
-        buf_pos = res;
-    }
-    res = write_all_blocks(s, buf + buf_pos, buf_size - buf_pos);
-    if (res < 0)
-        return res;
-    buf_pos += res;
-#ifndef FLASHSV2_DUMB
-    s->total_bits += ((double) buf_pos) * 8.0;
-#endif
-
-    return buf_pos;
-}
-
-static void recommend_keyframe(FlashSV2Context * s, int *keyframe)
-{
-#ifndef FLASHSV2_DUMB
-    double block_ratio, line_ratio, enc_ratio, comp_ratio, data_ratio;
-    if (s->avctx->gop_size > 0) {
-        block_ratio = s->diff_blocks / s->tot_blocks;
-        line_ratio = s->diff_lines / s->tot_lines;
-        enc_ratio = s->uncomp_size / s->raw_size;
-        comp_ratio = s->comp_size / s->uncomp_size;
-        data_ratio = s->comp_size / s->raw_size;
-
-        if ((block_ratio >= 0.5 && line_ratio / block_ratio <= 0.5) || line_ratio >= 0.95) {
-            *keyframe = 1;
-            return;
-        }
-    }
-#else
-    return;
-#endif
-}
-
-#ifndef FLASHSV2_DUMB
-static const double block_size_fraction = 1.0 / 300;
-static const double use15_7_threshold = 8192;
-static const double color15_7_factor = 100;
-#endif
-static int optimum_block_width(FlashSV2Context * s)
-{
-#ifndef FLASHSV2_DUMB
-    double save = (1-pow(s->diff_lines/s->diff_blocks/s->block_height, 0.5)) * s->comp_size/s->tot_blocks;
-    double width = block_size_fraction * sqrt(0.5 * save * s->rows * s->cols) * s->image_width;
-    int pwidth = ((int) width);
-    return FFCLIP(pwidth & ~15, 256, 16);
-#else
-    return 64;
-#endif
-}
-
-static int optimum_block_height(FlashSV2Context * s)
-{
-#ifndef FLASHSV2_DUMB
-    double save = (1-pow(s->diff_lines/s->diff_blocks/s->block_height, 0.5)) * s->comp_size/s->tot_blocks;
-    double height = block_size_fraction * sqrt(0.5 * save * s->rows * s->cols) * s->image_height;
-    int pheight = ((int) height);
-    return FFCLIP(pheight & ~15, 256, 16);
-#else
-    return 64;
-#endif
-}
-
-static int optimum_use15_7(FlashSV2Context * s)
-{
-#ifndef FLASHSV2_DUMB
-    double ideal = ((double)(s->avctx->bit_rate * s->avctx->time_base.den * s->avctx->ticks_per_frame)) /
-        ((double) s->avctx->time_base.num) * s->avctx->frame_num;
-    if (ideal + use15_7_threshold < s->total_bits) {
-        return 1;
-    } else {
-        return 0;
-    }
-#else
-    return s->avctx->global_quality == 0;
-#endif
-}
-
-static int optimum_dist(FlashSV2Context * s)
-{
-#ifndef FLASHSV2_DUMB
-    double ideal =
-        s->avctx->bit_rate * s->avctx->time_base.den *
-        s->avctx->ticks_per_frame;
-    int dist = pow((s->total_bits / ideal) * color15_7_factor, 3);
-    av_log(s->avctx, AV_LOG_DEBUG, "dist: %d\n", dist);
-    return dist;
-#else
-    return 15;
-#endif
-}
-
-
-static int reconfigure_at_keyframe(FlashSV2Context * s, const uint8_t * image,
-                                   int stride)
-{
-    int update_palette = 0;
-    int res;
-    int block_width  = optimum_block_width (s);
-    int block_height = optimum_block_height(s);
-
-    if (block_width != s->block_width || block_height != s->block_height) {
-        res = update_block_dimensions(s, block_width, block_height);
-        if (res < 0)
-            return res;
-    }
-
-    s->use15_7 = optimum_use15_7(s);
-    if (s->use15_7) {
-        if ((s->use_custom_palette && s->palette_type != 1) || update_palette) {
-            res = generate_optimum_palette(&s->palette, image, s->image_width, s->image_height, stride);
-            if (res)
-                return res;
-            s->palette_type = 1;
-            av_log(s->avctx, AV_LOG_DEBUG, "Generated optimum palette\n");
-        } else if (!s->use_custom_palette && s->palette_type != 0) {
-            res = generate_default_palette(&s->palette);
-            if (res)
-                return res;
-            s->palette_type = 0;
-            av_log(s->avctx, AV_LOG_DEBUG, "Generated default palette\n");
-        }
-    }
-
-
-    reset_stats(s);
-
-    return 0;
-}
-
-static int flashsv2_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
-                                 const AVFrame *p, int *got_packet)
-{
-    FlashSV2Context *const s = avctx->priv_data;
-    int res;
-    int keyframe = 0;
-
-    if ((res = ff_alloc_packet(avctx, pkt, s->frame_size + AV_INPUT_BUFFER_MIN_SIZE)) < 0)
-        return res;
-
-    /* First frame needs to be a keyframe */
-    if (avctx->frame_num == 0)
-        keyframe = 1;
-
-    /* Check the placement of keyframes */
-    if (avctx->gop_size > 0) {
-        if (avctx->frame_num >= s->last_key_frame + avctx->gop_size)
-            keyframe = 1;
-    }
-
-    if (!keyframe
-        && avctx->frame_num > s->last_key_frame + avctx->keyint_min) {
-        recommend_keyframe(s, &keyframe);
-        if (keyframe)
-            av_log(avctx, AV_LOG_DEBUG, "Recommending key frame at frame %"PRId64"\n", avctx->frame_num);
-    }
-
-    if (keyframe) {
-        res = reconfigure_at_keyframe(s, p->data[0], p->linesize[0]);
-        if (res)
-            return res;
-    }
-
-    if (s->use15_7)
-        s->dist = optimum_dist(s);
-
-    res = write_bitstream(s, p->data[0], p->linesize[0], pkt->data, pkt->size, keyframe);
-
-    if (keyframe) {
-        new_key_frame(s);
-        s->last_key_frame = avctx->frame_num;
-        pkt->flags |= AV_PKT_FLAG_KEY;
-        av_log(avctx, AV_LOG_DEBUG, "Inserting key frame at frame %"PRId64"\n", avctx->frame_num);
-    }
-
-    pkt->size = res;
-    *got_packet = 1;
-
-    return 0;
-}
-
-static av_cold int flashsv2_encode_end(AVCodecContext * avctx)
-{
-    FlashSV2Context *s = avctx->priv_data;
-
-    cleanup(s);
-
-    return 0;
-}
-
-const FFCodec ff_flashsv2_encoder = {
-    .p.name         = "flashsv2",
-    CODEC_LONG_NAME("Flash Screen Video Version 2"),
-    .p.type         = AVMEDIA_TYPE_VIDEO,
-    .p.id           = AV_CODEC_ID_FLASHSV2,
-    .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
-    .priv_data_size = sizeof(FlashSV2Context),
-    .init           = flashsv2_encode_init,
-    FF_CODEC_ENCODE_CB(flashsv2_encode_frame),
-    .close          = flashsv2_encode_end,
-    .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
-    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
-};
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/frame_thread_encoder.c b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/frame_thread_encoder.c
deleted file mode 100644
index 62d9580ad4c88946ae5633693887dff9e967790e..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/frame_thread_encoder.c
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- * Copyright (c) 2012 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include <stdatomic.h>
-
-#include "frame_thread_encoder.h"
-
-#include "libavutil/avassert.h"
-#include "libavutil/cpu.h"
-#include "libavutil/opt.h"
-#include "libavutil/thread.h"
-#include "avcodec.h"
-#include "encode.h"
-#include "internal.h"
-#include "pthread_internal.h"
-
-#define MAX_THREADS 64
-/* There can be as many as MAX_THREADS + 1 outstanding tasks.
- * An additional + 1 is needed so that one can distinguish
- * the case of zero and MAX_THREADS + 1 outstanding tasks modulo
- * the number of buffers. */
-#define BUFFER_SIZE (MAX_THREADS + 2)
-
-typedef struct{
-    AVFrame  *indata;
-    AVPacket *outdata;
-    int       return_code;
-    int       finished;
-    int       got_packet;
-} Task;
-
-typedef struct{
-    AVCodecContext *parent_avctx;
-
-    pthread_mutex_t task_fifo_mutex; /* Used to guard (next_)task_index */
-    pthread_cond_t task_fifo_cond;
-
-    unsigned pthread_init_cnt;
-    unsigned max_tasks;
-    Task tasks[BUFFER_SIZE];
-    pthread_mutex_t finished_task_mutex; /* Guards tasks[i].finished */
-    pthread_cond_t finished_task_cond;
-
-    unsigned next_task_index;
-    unsigned task_index;
-    unsigned finished_task_index;
-
-    pthread_t worker[MAX_THREADS];
-    atomic_int exit;
-} ThreadContext;
-
-#define OFF(member) offsetof(ThreadContext, member)
-DEFINE_OFFSET_ARRAY(ThreadContext, thread_ctx, pthread_init_cnt,
-                    (OFF(task_fifo_mutex), OFF(finished_task_mutex)),
-                    (OFF(task_fifo_cond),  OFF(finished_task_cond)));
-#undef OFF
-
-static void * attribute_align_arg worker(void *v){
-    AVCodecContext *avctx = v;
-    ThreadContext *c = avctx->internal->frame_thread_encoder;
-
-    while (!atomic_load(&c->exit)) {
-        int ret;
-        AVPacket *pkt;
-        AVFrame *frame;
-        Task *task;
-        unsigned task_index;
-
-        pthread_mutex_lock(&c->task_fifo_mutex);
-        while (c->next_task_index == c->task_index || atomic_load(&c->exit)) {
-            if (atomic_load(&c->exit)) {
-                pthread_mutex_unlock(&c->task_fifo_mutex);
-                goto end;
-            }
-            pthread_cond_wait(&c->task_fifo_cond, &c->task_fifo_mutex);
-        }
-        task_index         = c->next_task_index;
-        c->next_task_index = (c->next_task_index + 1) % c->max_tasks;
-        pthread_mutex_unlock(&c->task_fifo_mutex);
-        /* The main thread ensures that any two outstanding tasks have
-         * different indices, ergo each worker thread owns its element
-         * of c->tasks with the exception of finished, which is shared
-         * with the main thread and guarded by finished_task_mutex. */
-        task  = &c->tasks[task_index];
-        frame = task->indata;
-        pkt   = task->outdata;
-
-        ret = ff_encode_encode_cb(avctx, pkt, frame, &task->got_packet);
-        pthread_mutex_lock(&c->finished_task_mutex);
-        task->return_code = ret;
-        task->finished    = 1;
-        pthread_cond_signal(&c->finished_task_cond);
-        pthread_mutex_unlock(&c->finished_task_mutex);
-    }
-end:
-    avcodec_close(avctx);
-    av_freep(&avctx);
-    return NULL;
-}
-
-av_cold int ff_frame_thread_encoder_init(AVCodecContext *avctx)
-{
-    int i=0;
-    ThreadContext *c;
-    AVCodecContext *thread_avctx = NULL;
-    int ret;
-
-    if(   !(avctx->thread_type & FF_THREAD_FRAME)
-       || !(avctx->codec->capabilities & AV_CODEC_CAP_FRAME_THREADS))
-        return 0;
-
-    if(   !avctx->thread_count
-       && avctx->codec_id == AV_CODEC_ID_MJPEG
-       && !(avctx->flags & AV_CODEC_FLAG_QSCALE)) {
-        av_log(avctx, AV_LOG_DEBUG,
-               "Forcing thread count to 1 for MJPEG encoding, use -thread_type slice "
-               "or a constant quantizer if you want to use multiple cpu cores\n");
-        avctx->thread_count = 1;
-    }
-    if(   avctx->thread_count > 1
-       && avctx->codec_id == AV_CODEC_ID_MJPEG
-       && !(avctx->flags & AV_CODEC_FLAG_QSCALE))
-        av_log(avctx, AV_LOG_WARNING,
-               "MJPEG CBR encoding works badly with frame multi-threading, consider "
-               "using -threads 1, -thread_type slice or a constant quantizer.\n");
-
-    if (avctx->codec_id == AV_CODEC_ID_HUFFYUV ||
-        avctx->codec_id == AV_CODEC_ID_FFVHUFF) {
-        int warn = 0;
-        int64_t tmp;
-
-        if (avctx->flags & AV_CODEC_FLAG_PASS1)
-            warn = 1;
-        else if (av_opt_get_int(avctx->priv_data, "context", 0, &tmp) >= 0 &&
-                 tmp > 0) {
-            warn = av_opt_get_int(avctx->priv_data, "non_deterministic", 0, &tmp) < 0
-                   || !tmp;
-        }
-        // huffyuv does not support these with multiple frame threads currently
-        if (warn) {
-            av_log(avctx, AV_LOG_WARNING,
-               "Forcing thread count to 1 for huffyuv encoding with first pass or context 1\n");
-            avctx->thread_count = 1;
-        }
-    }
-
-    if(!avctx->thread_count) {
-        avctx->thread_count = av_cpu_count();
-        avctx->thread_count = FFMIN(avctx->thread_count, MAX_THREADS);
-    }
-
-    if(avctx->thread_count <= 1)
-        return 0;
-
-    if(avctx->thread_count > MAX_THREADS)
-        return AVERROR(EINVAL);
-
-    av_assert0(!avctx->internal->frame_thread_encoder);
-    c = avctx->internal->frame_thread_encoder = av_mallocz(sizeof(ThreadContext));
-    if(!c)
-        return AVERROR(ENOMEM);
-
-    c->parent_avctx = avctx;
-
-    ret = ff_pthread_init(c, thread_ctx_offsets);
-    if (ret < 0)
-        goto fail;
-    atomic_init(&c->exit, 0);
-
-    c->max_tasks = avctx->thread_count + 2;
-    for (unsigned j = 0; j < c->max_tasks; j++) {
-        if (!(c->tasks[j].indata  = av_frame_alloc()) ||
-            !(c->tasks[j].outdata = av_packet_alloc())) {
-            ret = AVERROR(ENOMEM);
-            goto fail;
-        }
-    }
-
-    for(i=0; i<avctx->thread_count ; i++){
-        void *tmpv;
-        thread_avctx = avcodec_alloc_context3(avctx->codec);
-        if (!thread_avctx) {
-            ret = AVERROR(ENOMEM);
-            goto fail;
-        }
-        tmpv = thread_avctx->priv_data;
-        *thread_avctx = *avctx;
-        thread_avctx->priv_data = tmpv;
-        thread_avctx->internal = NULL;
-        thread_avctx->hw_frames_ctx = NULL;
-        ret = av_opt_copy(thread_avctx, avctx);
-        if (ret < 0)
-            goto fail;
-        if (avctx->codec->priv_class) {
-            ret = av_opt_copy(thread_avctx->priv_data, avctx->priv_data);
-            if (ret < 0)
-                goto fail;
-        }
-        thread_avctx->thread_count = 1;
-        thread_avctx->active_thread_type &= ~FF_THREAD_FRAME;
-
-        if ((ret = avcodec_open2(thread_avctx, avctx->codec, NULL)) < 0)
-            goto fail;
-        av_assert0(!thread_avctx->internal->frame_thread_encoder);
-        thread_avctx->internal->frame_thread_encoder = c;
-        if ((ret = pthread_create(&c->worker[i], NULL, worker, thread_avctx))) {
-            ret = AVERROR(ret);
-            goto fail;
-        }
-    }
-
-    avctx->active_thread_type = FF_THREAD_FRAME;
-
-    return 0;
-fail:
-    avcodec_close(thread_avctx);
-    av_freep(&thread_avctx);
-    avctx->thread_count = i;
-    av_log(avctx, AV_LOG_ERROR, "ff_frame_thread_encoder_init failed\n");
-    ff_frame_thread_encoder_free(avctx);
-    return ret;
-}
-
-av_cold void ff_frame_thread_encoder_free(AVCodecContext *avctx)
-{
-    ThreadContext *c= avctx->internal->frame_thread_encoder;
-
-    /* In case initializing the mutexes/condition variables failed,
-     * they must not be used. In this case the thread_count is zero
-     * as no thread has been initialized yet. */
-    if (avctx->thread_count > 0) {
-        pthread_mutex_lock(&c->task_fifo_mutex);
-        atomic_store(&c->exit, 1);
-        pthread_cond_broadcast(&c->task_fifo_cond);
-        pthread_mutex_unlock(&c->task_fifo_mutex);
-
-        for (int i = 0; i < avctx->thread_count; i++)
-            pthread_join(c->worker[i], NULL);
-    }
-
-    for (unsigned i = 0; i < c->max_tasks; i++) {
-        av_frame_free(&c->tasks[i].indata);
-        av_packet_free(&c->tasks[i].outdata);
-    }
-
-    ff_pthread_free(c, thread_ctx_offsets);
-    av_freep(&avctx->internal->frame_thread_encoder);
-}
-
-int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
-                                 AVFrame *frame, int *got_packet_ptr)
-{
-    ThreadContext *c = avctx->internal->frame_thread_encoder;
-    Task *outtask;
-
-    av_assert1(!*got_packet_ptr);
-
-    if(frame){
-        av_frame_move_ref(c->tasks[c->task_index].indata, frame);
-
-        pthread_mutex_lock(&c->task_fifo_mutex);
-        c->task_index = (c->task_index + 1) % c->max_tasks;
-        pthread_cond_signal(&c->task_fifo_cond);
-        pthread_mutex_unlock(&c->task_fifo_mutex);
-    }
-
-    outtask = &c->tasks[c->finished_task_index];
-    pthread_mutex_lock(&c->finished_task_mutex);
-    /* The access to task_index in the following code is ok,
-     * because it is only ever changed by the main thread. */
-    if (c->task_index == c->finished_task_index ||
-        (frame && !outtask->finished &&
-         (c->task_index - c->finished_task_index + c->max_tasks) % c->max_tasks <= avctx->thread_count)) {
-            pthread_mutex_unlock(&c->finished_task_mutex);
-            return 0;
-        }
-    while (!outtask->finished) {
-        pthread_cond_wait(&c->finished_task_cond, &c->finished_task_mutex);
-    }
-    pthread_mutex_unlock(&c->finished_task_mutex);
-    /* We now own outtask completely: No worker thread touches it any more,
-     * because there is no outstanding task with this index. */
-    outtask->finished = 0;
-    av_packet_move_ref(pkt, outtask->outdata);
-    *got_packet_ptr = outtask->got_packet;
-    c->finished_task_index = (c->finished_task_index + 1) % c->max_tasks;
-
-    return outtask->return_code;
-}
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/mf_utils.c b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/mf_utils.c
deleted file mode 100644
index 48e3a63efc7f56fb43204285883944756f212dea..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/mf_utils.c
+++ /dev/null
@@ -1,649 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#define COBJMACROS
-#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0602
-#undef _WIN32_WINNT
-#define _WIN32_WINNT 0x0602
-#endif
-
-#include "mf_utils.h"
-#include "libavutil/pixdesc.h"
-
-HRESULT ff_MFGetAttributeSize(IMFAttributes *pattr, REFGUID guid,
-                              UINT32 *pw, UINT32 *ph)
-{
-    UINT64 t;
-    HRESULT hr = IMFAttributes_GetUINT64(pattr, guid, &t);
-    if (!FAILED(hr)) {
-        *pw = t >> 32;
-        *ph = (UINT32)t;
-    }
-    return hr;
-}
-
-HRESULT ff_MFSetAttributeSize(IMFAttributes *pattr, REFGUID guid,
-                              UINT32 uw, UINT32 uh)
-{
-    UINT64 t = (((UINT64)uw) << 32) | uh;
-    return IMFAttributes_SetUINT64(pattr, guid, t);
-}
-
-#define ff_MFSetAttributeRatio ff_MFSetAttributeSize
-#define ff_MFGetAttributeRatio ff_MFGetAttributeSize
-
-char *ff_hr_str_buf(char *buf, size_t size, HRESULT hr)
-{
-#define HR(x) case x: return (char *) # x;
-    switch (hr) {
-    HR(S_OK)
-    HR(E_UNEXPECTED)
-    HR(MF_E_INVALIDMEDIATYPE)
-    HR(MF_E_INVALIDSTREAMNUMBER)
-    HR(MF_E_INVALIDTYPE)
-    HR(MF_E_TRANSFORM_CANNOT_CHANGE_MEDIATYPE_WHILE_PROCESSING)
-    HR(MF_E_TRANSFORM_TYPE_NOT_SET)
-    HR(MF_E_UNSUPPORTED_D3D_TYPE)
-    HR(MF_E_TRANSFORM_NEED_MORE_INPUT)
-    HR(MF_E_TRANSFORM_STREAM_CHANGE)
-    HR(MF_E_NOTACCEPTING)
-    HR(MF_E_NO_SAMPLE_TIMESTAMP)
-    HR(MF_E_NO_SAMPLE_DURATION)
-#undef HR
-    }
-    snprintf(buf, size, "%x", (unsigned)hr);
-    return buf;
-}
-
-// If fill_data!=NULL, initialize the buffer and set the length. (This is a
-// subtle but important difference: some decoders want CurrentLength==0 on
-// provided output buffers.)
-IMFSample *ff_create_memory_sample(MFFunctions *f,void *fill_data, size_t size,
-                                   size_t align)
-{
-    HRESULT hr;
-    IMFSample *sample;
-    IMFMediaBuffer *buffer;
-
-    hr = f->MFCreateSample(&sample);
-    if (FAILED(hr))
-        return NULL;
-
-    align = FFMAX(align, 16); // 16 is "recommended", even if not required
-
-    hr = f->MFCreateAlignedMemoryBuffer(size, align - 1, &buffer);
-    if (FAILED(hr))
-        return NULL;
-
-    if (fill_data) {
-        BYTE *tmp;
-
-        hr = IMFMediaBuffer_Lock(buffer, &tmp, NULL, NULL);
-        if (FAILED(hr)) {
-            IMFMediaBuffer_Release(buffer);
-            IMFSample_Release(sample);
-            return NULL;
-        }
-        memcpy(tmp, fill_data, size);
-
-        IMFMediaBuffer_SetCurrentLength(buffer, size);
-        IMFMediaBuffer_Unlock(buffer);
-    }
-
-    IMFSample_AddBuffer(sample, buffer);
-    IMFMediaBuffer_Release(buffer);
-
-    return sample;
-}
-
-enum AVSampleFormat ff_media_type_to_sample_fmt(IMFAttributes *type)
-{
-    HRESULT hr;
-    UINT32 bits;
-    GUID subtype;
-
-    hr = IMFAttributes_GetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, &bits);
-    if (FAILED(hr))
-        return AV_SAMPLE_FMT_NONE;
-
-    hr = IMFAttributes_GetGUID(type, &MF_MT_SUBTYPE, &subtype);
-    if (FAILED(hr))
-        return AV_SAMPLE_FMT_NONE;
-
-    if (IsEqualGUID(&subtype, &MFAudioFormat_PCM)) {
-        switch (bits) {
-        case 8:  return AV_SAMPLE_FMT_U8;
-        case 16: return AV_SAMPLE_FMT_S16;
-        case 32: return AV_SAMPLE_FMT_S32;
-        }
-    } else if (IsEqualGUID(&subtype, &MFAudioFormat_Float)) {
-        switch (bits) {
-        case 32: return AV_SAMPLE_FMT_FLT;
-        case 64: return AV_SAMPLE_FMT_DBL;
-        }
-    }
-
-    return AV_SAMPLE_FMT_NONE;
-}
-
-struct mf_pix_fmt_entry {
-    const GUID *guid;
-    enum AVPixelFormat pix_fmt;
-};
-
-static const struct mf_pix_fmt_entry mf_pix_fmts[] = {
-    {&MFVideoFormat_IYUV, AV_PIX_FMT_YUV420P},
-    {&MFVideoFormat_I420, AV_PIX_FMT_YUV420P},
-    {&MFVideoFormat_NV12, AV_PIX_FMT_NV12},
-    {&MFVideoFormat_P010, AV_PIX_FMT_P010},
-    {&MFVideoFormat_P016, AV_PIX_FMT_P010}, // not equal, but compatible
-    {&MFVideoFormat_YUY2, AV_PIX_FMT_YUYV422},
-};
-
-enum AVPixelFormat ff_media_type_to_pix_fmt(IMFAttributes *type)
-{
-    HRESULT hr;
-    GUID subtype;
-    int i;
-
-    hr = IMFAttributes_GetGUID(type, &MF_MT_SUBTYPE, &subtype);
-    if (FAILED(hr))
-        return AV_PIX_FMT_NONE;
-
-    for (i = 0; i < FF_ARRAY_ELEMS(mf_pix_fmts); i++) {
-        if (IsEqualGUID(&subtype, mf_pix_fmts[i].guid))
-            return mf_pix_fmts[i].pix_fmt;
-    }
-
-    return AV_PIX_FMT_NONE;
-}
-
-const GUID *ff_pix_fmt_to_guid(enum AVPixelFormat pix_fmt)
-{
-    int i;
-
-    for (i = 0; i < FF_ARRAY_ELEMS(mf_pix_fmts); i++) {
-        if (mf_pix_fmts[i].pix_fmt == pix_fmt)
-            return mf_pix_fmts[i].guid;
-    }
-
-    return NULL;
-}
-
-// If this GUID is of the form XXXXXXXX-0000-0010-8000-00AA00389B71, then
-// extract the XXXXXXXX prefix as FourCC (oh the pain).
-int ff_fourcc_from_guid(const GUID *guid, uint32_t *out_fourcc)
-{
-    if (guid->Data2 == 0 && guid->Data3 == 0x0010 &&
-        guid->Data4[0] == 0x80 &&
-        guid->Data4[1] == 0x00 &&
-        guid->Data4[2] == 0x00 &&
-        guid->Data4[3] == 0xAA &&
-        guid->Data4[4] == 0x00 &&
-        guid->Data4[5] == 0x38 &&
-        guid->Data4[6] == 0x9B &&
-        guid->Data4[7] == 0x71) {
-        *out_fourcc = guid->Data1;
-        return 0;
-    }
-
-    *out_fourcc = 0;
-    return AVERROR_UNKNOWN;
-}
-
-struct GUID_Entry {
-    const GUID *guid;
-    const char *name;
-};
-
-#define GUID_ENTRY(var) {&(var), # var}
-
-static struct GUID_Entry guid_names[] = {
-    GUID_ENTRY(MFT_FRIENDLY_NAME_Attribute),
-    GUID_ENTRY(MFT_TRANSFORM_CLSID_Attribute),
-    GUID_ENTRY(MFT_ENUM_HARDWARE_URL_Attribute),
-    GUID_ENTRY(MFT_CONNECTED_STREAM_ATTRIBUTE),
-    GUID_ENTRY(MFT_CONNECTED_TO_HW_STREAM),
-    GUID_ENTRY(MF_SA_D3D_AWARE),
-    GUID_ENTRY(ff_MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT),
-    GUID_ENTRY(ff_MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT_PROGRESSIVE),
-    GUID_ENTRY(ff_MF_SA_D3D11_BINDFLAGS),
-    GUID_ENTRY(ff_MF_SA_D3D11_USAGE),
-    GUID_ENTRY(ff_MF_SA_D3D11_AWARE),
-    GUID_ENTRY(ff_MF_SA_D3D11_SHARED),
-    GUID_ENTRY(ff_MF_SA_D3D11_SHARED_WITHOUT_MUTEX),
-    GUID_ENTRY(MF_MT_SUBTYPE),
-    GUID_ENTRY(MF_MT_MAJOR_TYPE),
-    GUID_ENTRY(MF_MT_AUDIO_SAMPLES_PER_SECOND),
-    GUID_ENTRY(MF_MT_AUDIO_NUM_CHANNELS),
-    GUID_ENTRY(MF_MT_AUDIO_CHANNEL_MASK),
-    GUID_ENTRY(MF_MT_FRAME_SIZE),
-    GUID_ENTRY(MF_MT_INTERLACE_MODE),
-    GUID_ENTRY(MF_MT_USER_DATA),
-    GUID_ENTRY(MF_MT_PIXEL_ASPECT_RATIO),
-    GUID_ENTRY(MFMediaType_Audio),
-    GUID_ENTRY(MFMediaType_Video),
-    GUID_ENTRY(MFAudioFormat_PCM),
-    GUID_ENTRY(MFAudioFormat_Float),
-    GUID_ENTRY(MFVideoFormat_H264),
-    GUID_ENTRY(MFVideoFormat_H264_ES),
-    GUID_ENTRY(ff_MFVideoFormat_HEVC),
-    GUID_ENTRY(ff_MFVideoFormat_HEVC_ES),
-    GUID_ENTRY(MFVideoFormat_MPEG2),
-    GUID_ENTRY(MFVideoFormat_MP43),
-    GUID_ENTRY(MFVideoFormat_MP4V),
-    GUID_ENTRY(MFVideoFormat_WMV1),
-    GUID_ENTRY(MFVideoFormat_WMV2),
-    GUID_ENTRY(MFVideoFormat_WMV3),
-    GUID_ENTRY(MFVideoFormat_WVC1),
-    GUID_ENTRY(MFAudioFormat_Dolby_AC3),
-    GUID_ENTRY(MFAudioFormat_Dolby_DDPlus),
-    GUID_ENTRY(MFAudioFormat_AAC),
-    GUID_ENTRY(MFAudioFormat_MP3),
-    GUID_ENTRY(MFAudioFormat_MSP1),
-    GUID_ENTRY(MFAudioFormat_WMAudioV8),
-    GUID_ENTRY(MFAudioFormat_WMAudioV9),
-    GUID_ENTRY(MFAudioFormat_WMAudio_Lossless),
-    GUID_ENTRY(MF_MT_ALL_SAMPLES_INDEPENDENT),
-    GUID_ENTRY(MF_MT_COMPRESSED),
-    GUID_ENTRY(MF_MT_FIXED_SIZE_SAMPLES),
-    GUID_ENTRY(MF_MT_SAMPLE_SIZE),
-    GUID_ENTRY(MF_MT_WRAPPED_TYPE),
-    GUID_ENTRY(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION),
-    GUID_ENTRY(MF_MT_AAC_PAYLOAD_TYPE),
-    GUID_ENTRY(MF_MT_AUDIO_AVG_BYTES_PER_SECOND),
-    GUID_ENTRY(MF_MT_AUDIO_BITS_PER_SAMPLE),
-    GUID_ENTRY(MF_MT_AUDIO_BLOCK_ALIGNMENT),
-    GUID_ENTRY(MF_MT_AUDIO_CHANNEL_MASK),
-    GUID_ENTRY(MF_MT_AUDIO_FLOAT_SAMPLES_PER_SECOND),
-    GUID_ENTRY(MF_MT_AUDIO_FOLDDOWN_MATRIX),
-    GUID_ENTRY(MF_MT_AUDIO_NUM_CHANNELS),
-    GUID_ENTRY(MF_MT_AUDIO_PREFER_WAVEFORMATEX),
-    GUID_ENTRY(MF_MT_AUDIO_SAMPLES_PER_BLOCK),
-    GUID_ENTRY(MF_MT_AUDIO_SAMPLES_PER_SECOND),
-    GUID_ENTRY(MF_MT_AUDIO_VALID_BITS_PER_SAMPLE),
-    GUID_ENTRY(MF_MT_AUDIO_WMADRC_AVGREF),
-    GUID_ENTRY(MF_MT_AUDIO_WMADRC_AVGTARGET),
-    GUID_ENTRY(MF_MT_AUDIO_WMADRC_PEAKREF),
-    GUID_ENTRY(MF_MT_AUDIO_WMADRC_PEAKTARGET),
-    GUID_ENTRY(MF_MT_AVG_BIT_ERROR_RATE),
-    GUID_ENTRY(MF_MT_AVG_BITRATE),
-    GUID_ENTRY(MF_MT_DEFAULT_STRIDE),
-    GUID_ENTRY(MF_MT_DRM_FLAGS),
-    GUID_ENTRY(MF_MT_FRAME_RATE),
-    GUID_ENTRY(MF_MT_FRAME_RATE_RANGE_MAX),
-    GUID_ENTRY(MF_MT_FRAME_RATE_RANGE_MIN),
-    GUID_ENTRY(MF_MT_FRAME_SIZE),
-    GUID_ENTRY(MF_MT_GEOMETRIC_APERTURE),
-    GUID_ENTRY(MF_MT_INTERLACE_MODE),
-    GUID_ENTRY(MF_MT_MAX_KEYFRAME_SPACING),
-    GUID_ENTRY(MF_MT_MINIMUM_DISPLAY_APERTURE),
-    GUID_ENTRY(MF_MT_MPEG_SEQUENCE_HEADER),
-    GUID_ENTRY(MF_MT_MPEG_START_TIME_CODE),
-    GUID_ENTRY(MF_MT_MPEG2_FLAGS),
-    GUID_ENTRY(MF_MT_MPEG2_LEVEL),
-    GUID_ENTRY(MF_MT_MPEG2_PROFILE),
-    GUID_ENTRY(MF_MT_PAD_CONTROL_FLAGS),
-    GUID_ENTRY(MF_MT_PALETTE),
-    GUID_ENTRY(MF_MT_PAN_SCAN_APERTURE),
-    GUID_ENTRY(MF_MT_PAN_SCAN_ENABLED),
-    GUID_ENTRY(MF_MT_PIXEL_ASPECT_RATIO),
-    GUID_ENTRY(MF_MT_SOURCE_CONTENT_HINT),
-    GUID_ENTRY(MF_MT_TRANSFER_FUNCTION),
-    GUID_ENTRY(MF_MT_VIDEO_CHROMA_SITING),
-    GUID_ENTRY(MF_MT_VIDEO_LIGHTING),
-    GUID_ENTRY(MF_MT_VIDEO_NOMINAL_RANGE),
-    GUID_ENTRY(MF_MT_VIDEO_PRIMARIES),
-    GUID_ENTRY(MF_MT_VIDEO_ROTATION),
-    GUID_ENTRY(MF_MT_YUV_MATRIX),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoThumbnailGenerationMode),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoDropPicWithMissingRef),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoSoftwareDeinterlaceMode),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoFastDecodeMode),
-    GUID_ENTRY(ff_CODECAPI_AVLowLatencyMode),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoH264ErrorConcealment),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoMPEG2ErrorConcealment),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoCodecType),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoDXVAMode),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoDXVABusEncryption),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoSWPowerLevel),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoMaxCodedWidth),
-    GUID_ENTRY(ff_CODECAPI_AVDecVideoMaxCodedHeight),
-    GUID_ENTRY(ff_CODECAPI_AVDecNumWorkerThreads),
-    GUID_ENTRY(ff_CODECAPI_AVDecSoftwareDynamicFormatChange),
-    GUID_ENTRY(ff_CODECAPI_AVDecDisableVideoPostProcessing),
-};
-
-char *ff_guid_str_buf(char *buf, size_t buf_size, const GUID *guid)
-{
-    uint32_t fourcc;
-    int n;
-    for (n = 0; n < FF_ARRAY_ELEMS(guid_names); n++) {
-        if (IsEqualGUID(guid, guid_names[n].guid)) {
-            snprintf(buf, buf_size, "%s", guid_names[n].name);
-            return buf;
-        }
-    }
-
-    if (ff_fourcc_from_guid(guid, &fourcc) >= 0) {
-        snprintf(buf, buf_size, "<FourCC %s>", av_fourcc2str(fourcc));
-        return buf;
-    }
-
-    snprintf(buf, buf_size,
-             "{%8.8x-%4.4x-%4.4x-%2.2x%2.2x-%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x}",
-             (unsigned) guid->Data1, guid->Data2, guid->Data3,
-             guid->Data4[0], guid->Data4[1],
-             guid->Data4[2], guid->Data4[3],
-             guid->Data4[4], guid->Data4[5],
-             guid->Data4[6], guid->Data4[7]);
-    return buf;
-}
-
-void ff_attributes_dump(void *log, IMFAttributes *attrs)
-{
-    HRESULT hr;
-    UINT32 count;
-    int n;
-
-    hr = IMFAttributes_GetCount(attrs, &count);
-    if (FAILED(hr))
-        return;
-
-    for (n = 0; n < count; n++) {
-        GUID key;
-        MF_ATTRIBUTE_TYPE type;
-        char extra[80] = {0};
-        const char *name = NULL;
-
-        hr = IMFAttributes_GetItemByIndex(attrs, n, &key, NULL);
-        if (FAILED(hr))
-            goto err;
-
-        name = ff_guid_str(&key);
-
-        if (IsEqualGUID(&key, &MF_MT_AUDIO_CHANNEL_MASK)) {
-            UINT32 v;
-            hr = IMFAttributes_GetUINT32(attrs, &key, &v);
-            if (FAILED(hr))
-                goto err;
-            snprintf(extra, sizeof(extra), " (0x%x)", (unsigned)v);
-        } else if (IsEqualGUID(&key, &MF_MT_FRAME_SIZE)) {
-            UINT32 w, h;
-
-            hr = ff_MFGetAttributeSize(attrs, &MF_MT_FRAME_SIZE, &w, &h);
-            if (FAILED(hr))
-                goto err;
-            snprintf(extra, sizeof(extra), " (%dx%d)", (int)w, (int)h);
-        } else if (IsEqualGUID(&key, &MF_MT_PIXEL_ASPECT_RATIO) ||
-                   IsEqualGUID(&key, &MF_MT_FRAME_RATE)) {
-            UINT32 num, den;
-
-            hr = ff_MFGetAttributeRatio(attrs, &key, &num, &den);
-            if (FAILED(hr))
-                goto err;
-            snprintf(extra, sizeof(extra), " (%d:%d)", (int)num, (int)den);
-        }
-
-        hr = IMFAttributes_GetItemType(attrs, &key, &type);
-        if (FAILED(hr))
-            goto err;
-
-        switch (type) {
-        case MF_ATTRIBUTE_UINT32: {
-            UINT32 v;
-            hr = IMFAttributes_GetUINT32(attrs, &key, &v);
-            if (FAILED(hr))
-                goto err;
-            av_log(log, AV_LOG_VERBOSE, "   %s=%d%s\n", name, (int)v, extra);
-            break;
-        case MF_ATTRIBUTE_UINT64: {
-            UINT64 v;
-            hr = IMFAttributes_GetUINT64(attrs, &key, &v);
-            if (FAILED(hr))
-                goto err;
-            av_log(log, AV_LOG_VERBOSE, "   %s=%lld%s\n", name, (long long)v, extra);
-            break;
-        }
-        case MF_ATTRIBUTE_DOUBLE: {
-            DOUBLE v;
-            hr = IMFAttributes_GetDouble(attrs, &key, &v);
-            if (FAILED(hr))
-                goto err;
-            av_log(log, AV_LOG_VERBOSE, "   %s=%f%s\n", name, (double)v, extra);
-            break;
-        }
-        case MF_ATTRIBUTE_STRING: {
-            wchar_t s[512]; // being lazy here
-            hr = IMFAttributes_GetString(attrs, &key, s, sizeof(s), NULL);
-            if (FAILED(hr))
-                goto err;
-            av_log(log, AV_LOG_VERBOSE, "   %s='%ls'%s\n", name, s, extra);
-            break;
-        }
-        case MF_ATTRIBUTE_GUID: {
-            GUID v;
-            hr = IMFAttributes_GetGUID(attrs, &key, &v);
-            if (FAILED(hr))
-                goto err;
-            av_log(log, AV_LOG_VERBOSE, "   %s=%s%s\n", name, ff_guid_str(&v), extra);
-            break;
-        }
-        case MF_ATTRIBUTE_BLOB: {
-            UINT32 sz;
-            UINT8 buffer[100];
-            hr = IMFAttributes_GetBlobSize(attrs, &key, &sz);
-            if (FAILED(hr))
-                goto err;
-            if (sz <= sizeof(buffer)) {
-                // hex-dump it
-                char str[512] = {0};
-                size_t pos = 0;
-                hr = IMFAttributes_GetBlob(attrs, &key, buffer, sizeof(buffer), &sz);
-                if (FAILED(hr))
-                    goto err;
-                for (pos = 0; pos < sz; pos++) {
-                    const char *hex = "0123456789ABCDEF";
-                    if (pos * 3 + 3 > sizeof(str))
-                        break;
-                    str[pos * 3 + 0] = hex[buffer[pos] >> 4];
-                    str[pos * 3 + 1] = hex[buffer[pos] & 15];
-                    str[pos * 3 + 2] = ' ';
-                }
-                str[pos * 3 + 0] = 0;
-                av_log(log, AV_LOG_VERBOSE, "   %s=<blob size %d: %s>%s\n", name, (int)sz, str, extra);
-            } else {
-                av_log(log, AV_LOG_VERBOSE, "   %s=<blob size %d>%s\n", name, (int)sz, extra);
-            }
-            break;
-        }
-        case MF_ATTRIBUTE_IUNKNOWN: {
-            av_log(log, AV_LOG_VERBOSE, "   %s=<IUnknown>%s\n", name, extra);
-            break;
-        }
-        default:
-            av_log(log, AV_LOG_VERBOSE, "   %s=<unknown type>%s\n", name, extra);
-            break;
-        }
-        }
-
-        if (IsEqualGUID(&key, &MF_MT_SUBTYPE)) {
-            const char *fmt;
-            fmt = av_get_sample_fmt_name(ff_media_type_to_sample_fmt(attrs));
-            if (fmt)
-                av_log(log, AV_LOG_VERBOSE, "   FF-sample-format=%s\n", fmt);
-
-            fmt = av_get_pix_fmt_name(ff_media_type_to_pix_fmt(attrs));
-            if (fmt)
-                av_log(log, AV_LOG_VERBOSE, "   FF-pixel-format=%s\n", fmt);
-        }
-
-        continue;
-    err:
-        av_log(log, AV_LOG_VERBOSE, "   %s=<failed to get value>\n", name ? name : "?");
-    }
-}
-
-void ff_media_type_dump(void *log, IMFMediaType *type)
-{
-    ff_attributes_dump(log, (IMFAttributes *)type);
-}
-
-const CLSID *ff_codec_to_mf_subtype(enum AVCodecID codec)
-{
-    switch (codec) {
-    case AV_CODEC_ID_H264:              return &MFVideoFormat_H264;
-    case AV_CODEC_ID_HEVC:              return &ff_MFVideoFormat_HEVC;
-    case AV_CODEC_ID_AC3:               return &MFAudioFormat_Dolby_AC3;
-    case AV_CODEC_ID_AAC:               return &MFAudioFormat_AAC;
-    case AV_CODEC_ID_MP3:               return &MFAudioFormat_MP3;
-    default:                            return NULL;
-    }
-}
-
-static int init_com_mf(void *log, MFFunctions *f)
-{
-    HRESULT hr;
-
-    hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
-    if (hr == RPC_E_CHANGED_MODE) {
-        av_log(log, AV_LOG_ERROR, "COM must not be in STA mode\n");
-        return AVERROR(EINVAL);
-    } else if (FAILED(hr)) {
-        av_log(log, AV_LOG_ERROR, "could not initialize COM\n");
-        return AVERROR(ENOSYS);
-    }
-
-    hr = f->MFStartup(MF_VERSION, MFSTARTUP_FULL);
-    if (FAILED(hr)) {
-        av_log(log, AV_LOG_ERROR, "could not initialize MediaFoundation\n");
-        CoUninitialize();
-        return AVERROR(ENOSYS);
-    }
-
-    return 0;
-}
-
-static void uninit_com_mf(MFFunctions *f)
-{
-    f->MFShutdown();
-    CoUninitialize();
-}
-
-// Find and create a IMFTransform with the given input/output types. When done,
-// you should use ff_free_mf() to destroy it, which will also uninit COM.
-int ff_instantiate_mf(void *log,
-                      MFFunctions *f,
-                      GUID category,
-                      MFT_REGISTER_TYPE_INFO *in_type,
-                      MFT_REGISTER_TYPE_INFO *out_type,
-                      int use_hw,
-                      IMFTransform **res)
-{
-    HRESULT hr;
-    int n;
-    int ret;
-    IMFActivate **activate;
-    UINT32 num_activate;
-    IMFActivate *winner = 0;
-    UINT32 flags;
-
-    ret = init_com_mf(log, f);
-    if (ret < 0)
-        return ret;
-
-    flags = MFT_ENUM_FLAG_SORTANDFILTER;
-
-    if (use_hw) {
-        flags |= MFT_ENUM_FLAG_HARDWARE;
-    } else {
-        flags |= MFT_ENUM_FLAG_SYNCMFT;
-    }
-
-    hr = f->MFTEnumEx(category, flags, in_type, out_type, &activate,
-                      &num_activate);
-    if (FAILED(hr))
-        goto error_uninit_mf;
-
-    if (log) {
-        if (!num_activate)
-            av_log(log, AV_LOG_ERROR, "could not find any MFT for the given media type\n");
-
-        for (n = 0; n < num_activate; n++) {
-            av_log(log, AV_LOG_VERBOSE, "MF %d attributes:\n", n);
-            ff_attributes_dump(log, (IMFAttributes *)activate[n]);
-        }
-    }
-
-    *res = NULL;
-    for (n = 0; n < num_activate; n++) {
-        if (log)
-            av_log(log, AV_LOG_VERBOSE, "activate MFT %d\n", n);
-        hr = IMFActivate_ActivateObject(activate[n], &IID_IMFTransform,
-                                        (void **)res);
-        if (*res) {
-            winner = activate[n];
-            IMFActivate_AddRef(winner);
-            break;
-        }
-    }
-
-    for (n = 0; n < num_activate; n++)
-       IMFActivate_Release(activate[n]);
-    CoTaskMemFree(activate);
-
-    if (!*res) {
-        if (log)
-            av_log(log, AV_LOG_ERROR, "could not create MFT\n");
-        goto error_uninit_mf;
-    }
-
-    if (log) {
-        wchar_t s[512]; // being lazy here
-        IMFAttributes *attrs;
-        hr = IMFTransform_GetAttributes(*res, &attrs);
-        if (!FAILED(hr) && attrs) {
-
-            av_log(log, AV_LOG_VERBOSE, "MFT attributes\n");
-            ff_attributes_dump(log, attrs);
-            IMFAttributes_Release(attrs);
-        }
-
-        hr = IMFActivate_GetString(winner, &MFT_FRIENDLY_NAME_Attribute, s,
-                                   sizeof(s), NULL);
-        if (!FAILED(hr))
-            av_log(log, AV_LOG_INFO, "MFT name: '%ls'\n", s);
-
-    }
-
-    IMFActivate_Release(winner);
-
-    return 0;
-
-error_uninit_mf:
-    uninit_com_mf(f);
-    return AVERROR(ENOSYS);
-}
-
-void ff_free_mf(MFFunctions *f, IMFTransform **mft)
-{
-    if (*mft)
-        IMFTransform_Release(*mft);
-    *mft = NULL;
-    uninit_com_mf(f);
-}
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Car Parking Multiplayer Mod Apk  OBB Data Experience Realistic Car Physics and Customization.md b/spaces/congsaPfin/Manga-OCR/logs/Car Parking Multiplayer Mod Apk  OBB Data Experience Realistic Car Physics and Customization.md
deleted file mode 100644
index 18545698f5671a795e1aa23767cbd875b957d9e0..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Car Parking Multiplayer Mod Apk  OBB Data Experience Realistic Car Physics and Customization.md	
+++ /dev/null
@@ -1,80 +0,0 @@
-<br />
-<h1>Car Parking Multiplayer APK OBB Mod: A Review</h1>
-<p>If you are a fan of car simulation games, you might have heard of Car Parking Multiplayer. It is one of the most popular and realistic car parking games on Android devices. In this game, you can drive various cars, park them in different scenarios, customize them to your liking, and even interact with other players online. But what if you want to enjoy the game without any limitations or restrictions? That's where Car Parking Multiplayer APK OBB Mod comes in handy. In this article, we will review what this mod is, what benefits it offers, and how to download and install it on your device.</p>
-<h2>car parking multiplayer apk obb mod</h2><br /><p><b><b>Download File</b> &#10084;&#10084;&#10084; <a href="https://urlca.com/2uOcym">https://urlca.com/2uOcym</a></b></p><br /><br />
- <h2>What is Car Parking Multiplayer?</h2>
-<p>Car Parking Multiplayer is a car simulation game developed by olzhass. It has more than 100 million downloads on Google Play Store and a rating of 4.3 out of 5 stars. The game aims to provide a realistic and immersive car parking experience for players who love cars and driving.</p>
- <h3>Features of Car Parking Multiplayer</h3>
-<p>The game has many features that make it stand out from other car parking games. Here are some of them:</p>
- <h4>Realistic car physics and graphics</h4>
-<p>The game uses advanced car physics and graphics to simulate the behavior and appearance of real cars. You can feel the weight, speed, acceleration, braking, steering, suspension, and damage of each car. You can also see the details of the interior and exterior of each car, such as the dashboard, seats, lights, mirrors, wheels, tires, paint, stickers, etc.</p>
- <h4>Open world map and multiplayer mode</h4>
-<p>The game offers a large open world map with various locations and environments to explore. You can drive around the city, countryside, airport, desert, snow, etc. You can also join or create online rooms with up to 100 players and chat with them using voice or text messages. You can race with them, cooperate with them, or compete with them in different parking challenges.</p>
- <h4>Customization and tuning options</h4>
-<p>The game allows you to customize and tune your cars to your liking. You can change the color, wheels, tires, suspension, engine, transmission, exhaust, turbo, etc. You can also add accessories such as spoilers, bumpers, hoods, roofs, lights, horns, etc. You can even create your own car using the car editor feature.</p>
- <h4>Different game modes and challenges</h4>
-<p>The game has different game modes and challenges to test your driving and parking skills. You can play the classic parking mode where you have to park your car in a designated spot without hitting any obstacles or other cars. You can also play the free driving mode where you can roam around the map freely without any rules or objectives. You can also play the fun mode where you can do stunts, drifts, jumps, etc. You can also play the police mode where you can chase or be chased by other players in a police car. You can also play the delivery mode where you have to deliver goods or passengers to different destinations. You can also play the multiplayer mode where you can join or create online rooms with other players and chat with them using voice or text messages.</p>
-<p>car parking multiplayer mod apk unlimited money and gold<br />
-car parking multiplayer hack apk download for android<br />
-car parking multiplayer mod menu apk latest version<br />
-car parking multiplayer obb file download 2021<br />
-car parking multiplayer mod apk all cars unlocked<br />
-car parking multiplayer apk download for pc<br />
-car parking multiplayer mod apk ios no jailbreak<br />
-car parking multiplayer hack online generator<br />
-car parking multiplayer obb data highly compressed<br />
-car parking multiplayer mod apk revdl<br />
-car parking multiplayer apk free download full version<br />
-car parking multiplayer hack apk 4.8.9.2.1<br />
-car parking multiplayer mod apk rexdl<br />
-car parking multiplayer obb file location<br />
-car parking multiplayer mod apk android 1<br />
-car parking multiplayer apk pure no ads<br />
-car parking multiplayer hack apk unlimited coins and gems<br />
-car parking multiplayer mod apk offline mode<br />
-car parking multiplayer obb file size<br />
-car parking multiplayer mod apk an1<br />
-car parking multiplayer apk uptodown latest update<br />
-car parking multiplayer hack tool no survey no password<br />
-car parking multiplayer mod apk unlimited everything<br />
-car parking multiplayer obb file name<br />
-car parking multiplayer mod apk happymod</p>
- <h2>What is Car Parking Multiplayer APK OBB Mod?</h2>
-<p>Car Parking Multiplayer APK OBB Mod is a modified version of the original game that gives you access to unlimited money and resources, all cars unlocked and upgraded, no ads, and no root required. You can download and install this mod on your Android device and enjoy the game without any limitations or restrictions.</p>
- <h3>Benefits of Car Parking Multiplayer APK OBB Mod</h3>
-<p>There are many benefits of using Car Parking Multiplayer APK OBB Mod. Here are some of them:</p>
- <h4>Unlimited money and resources</h4>
-<p>With this mod, you will have unlimited money and resources in the game. You can use them to buy, customize, and tune any car you want. You can also use them to buy accessories, stickers, paint, etc. You can also use them to unlock new locations, game modes, and challenges. You will never run out of money or resources in the game.</p>
- <h4>All cars unlocked and upgraded</h4>
-<p>With this mod, you will have all cars unlocked and upgraded in the game. You can choose from over 100 cars of different brands, models, and types. You can also upgrade them to the maximum level and make them faster, stronger, and more efficient. You can also create your own car using the car editor feature.</p>
- <h4>No ads and no root required</h4>
-<p>With this mod, you will not see any ads in the game. You will not be interrupted by annoying pop-ups or banners while playing the game. You will also not need to root your device to install this mod. You can install it easily and safely without any risk of damaging your device or losing your data.</p>
- <h3>How to download and install Car Parking Multiplayer APK OBB Mod?</h3>
-<p>If you want to download and install Car Parking Multiplayer APK OBB Mod on your device, you need to follow these steps:</p>
- <h4>Step 1: Download the APK and OBB files from a trusted source</h4>
-<p>You need to download the APK and OBB files from a trusted source that provides safe and virus-free downloads. You can use the link below to download the files:</p>
-<p><a href="">Car Parking Multiplayer APK OBB Mod Download Link</a></p>
- <h4>Step 2: Enable unknown sources on your device settings</h4>
-<p>You need to enable unknown sources on your device settings to allow the installation of apps from sources other than Google Play Store. To do this, go to Settings > Security > Unknown Sources and toggle it on.</p>
- <h4>Step 3: Install the APK file and extract the OBB file to the Android/obb folder</h4>
-<p>You need to install the APK file by tapping on it and following the instructions on the screen. After that, you need to extract the OBB file using a file manager app such as ES File Explorer or ZArchiver. You need to copy or move the extracted folder named com.olzhas.carparking.multyplayer to the Android/obb folder on your device storage.</p>
- <h4>Step 4: Launch the game and enjoy</h4>
-<p>You need to launch the game by tapping on its icon on your home screen or app drawer. You will see a confirmation message that says "Modded by xyz". This means that the mod is working properly. You can now enjoy the game with unlimited money and resources, all cars unlocked and upgraded, no ads, and no root required.</p>
- <h2>Conclusion</h2>
-<p>Car Parking Multiplayer is a fun and realistic car simulation game that lets you drive various cars, park them in different scenarios, customize them to your liking, and interact with other players online. However, if you want to enjoy the game without any limitations or restrictions, you can use Car Parking Multiplayer APK OBB Mod. This mod gives you access to unlimited money and resources, all cars unlocked and upgraded, no ads, and no root required. You can download and install this mod easily and safely by following the steps above.</p>
- <h3>FAQs</h3>
-<p>Here are some frequently asked questions about Car Parking Multiplayer APK OBB Mod:</p>
- <ol>
-<li><b>Is Car Parking Multiplayer APK OBB Mod safe to use?</b></li>
-<p>Yes, Car Parking Multiplayer APK OBB Mod is safe to use as long as you download it from a trusted source that provides virus-free downloads. You also do not need to root your device to install this mod, which means you will not risk damaging your device or losing your data.</p>
- <li><b>Will I get banned for using Car Parking Multiplayer APK OBB Mod?</b></li>
-<p>No, you will not get banned for using Car Parking Multiplayer APK OBB Mod as long as you use it wisely and responsibly. You should not abuse the mod features or cheat in online rooms with other players. You should also respect the game developers and support them by buying the original game if you like it.</p>
- <li><b>Can I update Car Parking Multiplayer APK OBB Mod?</b></li>
-<p>Yes, you can update Car Parking Multiplayer APK OBB Mod whenever a new version is available. However, you need to download and install the new version from the same source that you downloaded the previous version. You also need to follow the same steps as before to install the new version. You may need to uninstall the old version first before installing the new one.</p>
- <li><b>Can I play Car Parking Multiplayer APK OBB Mod offline?</b></li>
-<p>Yes, you can play Car Parking Multiplayer APK OBB Mod offline without any internet connection. You can enjoy the game modes and challenges that do not require online interaction. However, if you want to play online with other players, you need to have a stable internet connection.</p>
- <li><b>Can I play Car Parking Multiplayer APK OBB Mod on PC?</b></li>
-<p>Yes, you can play Car Parking Multiplayer APK OBB Mod on PC using an Android emulator such as BlueStacks or NoxPlayer. You need to download and install the emulator on your PC and then download and install the mod on the emulator. You can then launch the game and enjoy it on a bigger screen.</p>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Free PDF Download of Phatak Materia Medica of Homoeopathic Medicines by S. R. Phatak.md b/spaces/congsaPfin/Manga-OCR/logs/Free PDF Download of Phatak Materia Medica of Homoeopathic Medicines by S. R. Phatak.md
deleted file mode 100644
index 569ec4fab373acf7f7f79bad82602e501b9d7f50..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Free PDF Download of Phatak Materia Medica of Homoeopathic Medicines by S. R. Phatak.md	
+++ /dev/null
@@ -1,131 +0,0 @@
-<br />
-<h1>Phatak Materia Medica PDF Free Download: A Review of a Classic Homeopathic Book</h1>
- <p>If you are interested in homeopathy, you may have heard of a book called <em>Materia Medica of Homoeopathic Medicines</em> by Dr. S.R. Phatak. This book is one of the most popular and widely used materia medicas in the world. But what is a materia medica and why is it important for homeopathy? Who is Dr. S.R. Phatak and what is his contribution to homeopathy? What are the main features and benefits of his book? And how can you download it for free from various sources? In this article, we will answer these questions and more.</p>
-<h2>phatak materia medica pdf free download</h2><br /><p><b><b>DOWNLOAD</b> &#9734; <a href="https://urlca.com/2uObAD">https://urlca.com/2uObAD</a></b></p><br /><br />
- <h2>What is a materia medica and why is it important for homeopathy?</h2>
- <p>A materia medica (Latin for "medical material") is a collection of information about the therapeutic properties of any substance used for healing, such as herbs, minerals, animals, or chemicals. In homeopathy, a materia medica describes how different substances affect the human body and mind when given in small doses, according to the principle of "like cures like". A materia medica also provides indications, modalities, relationships, dosage, and preparation methods for each remedy.</p>
- <p>A materia medica is important for homeopathy because it helps practitioners and students to select the most suitable remedy for each individual case, based on the totality of symptoms, personality, constitution, and history of the patient. A good materia medica also helps to deepen the understanding of the nature, action, and scope of each remedy, as well as to compare and differentiate similar remedies.</p>
- <h2>Who is Dr. S.R. Phatak and what is his contribution to homeopathy?</h2>
- <p>Dr. Shankar Raghunath Phatak (1896-1988) was a pioneer of homeopathy in Maharashtra, India. He was born in a Brahmin family and graduated from Grant Medical College in 1924. He started his practice as an allopathic doctor but soon became dissatisfied with its limitations and side effects. He was inspired by Sir William Osler's writings on the history of medicine to switch to homeopathy in 1932.</p>
- <p>Dr. Phatak was a prolific writer and teacher of homeopathy. He wrote several books, articles, lectures, and case reports on various aspects of homeopathy, such as philosophy, organon, repertory, materia medica, therapeutics, case taking, potency selection, etc. He also translated many classical works from English to Marathi. His most famous book is <em>Materia Medica of Homoeopathic Medicines</em>, which was first published in 1958 and has been reprinted several times since then. It is considered as one of the most concise and comprehensive materia medicas in homeopathy, covering more than 1000 remedies with their keynotes, indications, modalities, relationships, and clinical tips.</p>
- <h2>How to download the book for free from various sources?</h2>
- <p>If you want to read this classic book, you don't have to buy a hard copy or an e-book. You can download it for free from various online sources, such as:</p>
-<p>phatak concise materia medica pdf free download<br />
-phatak materia medica of homeopathic medicines pdf free download<br />
-phatak materia medica book pdf free download<br />
-phatak materia medica narayana verlag pdf free download<br />
-phatak materia medica homeopathybooks in pdf free download<br />
-phatak materia medica open library pdf free download<br />
-phatak materia medica by s r phatak pdf free download<br />
-phatak materia medica of homoeopathic medicines b jain pdf free download<br />
-phatak materia medica reading excerpt pdf free download<br />
-phatak materia medica publisher narayana verlag pdf free download<br />
-phatak materia medica generalities modalities and mind pdf free download<br />
-phatak materia medica preface by dr s r phatak pdf free download<br />
-phatak materia medica abies canadensis to zincum metallicum pdf free download<br />
-phatak materia medica clinically confirmed symptoms pdf free download<br />
-phatak materia medica a pioneer of homoeopathy in maharashtra pdf free download<br />
-phatak materia medica born on 6th september 1896 pdf free download<br />
-phatak materia medica did his mbbs from grant medical college pdf free download<br />
-phatak materia medica switched over to homoeopathy in 1932 pdf free download<br />
-phatak materia medica published in 1977 pdf free download<br />
-phatak materia medica marks of identification of the drug pdf free download<br />
-phatak materia medica aralia racemosa to bismuthum pdf free download<br />
-phatak materia medica boricum acidum to bothrops lanciolatus pdf free download<br />
-phatak materia medica bovista to cactus grandiflorus pdf free download<br />
-phatak materia medica cadmium sulphuratum to chamomilla pdf free download<br />
-phatak materia medica chelidonium majus to crotalus horridus pdf free download<br />
-phatak materia medica crotalus cascavella to digitalis purpurea pdf free download<br />
-phatak materia medica dioscorea villosa to ferrum metallicum pdf free download<br />
-phatak materia medica ferrum phosphoricum to graphites pdf free download<br />
-phatak materia medica gratiola officinalis to hydrastis canadensis pdf free download<br />
-phatak materia medica hydrocotyle asiatica to kali carbonicum pdf free download<br />
-phatak materia medica kali chloricum to lac caninum pdf free download<br />
-phatak materia medica lac defloratum to lycopodium clavatum pdf free download<br />
-phatak materia medica lyssinum to mercurius solubilis hahnemanni pdf free download<br />
-phatak materia medica mezereum to natrum muriaticum pdf free download<br />
-phatak materia medica natrum phosphoricum to nux vomica pdf free download<br />
-phatak materia medica oleander to phosphorus pdf free download<br />
-phatak materia medica physostigma venenosum to ranunculus bulbosus pdf free download<br />
-phatak materia medica ranunculus sceleratus to ruta graveolens pdf free download<br />
-phatak materia medica sabadilla to silicea terra pdf free download<br />
-phatak materia medica spigelia anthelmia to sulphur iodatum pdf free download<br />
-phatak materia medica sulphuricum acidum to thuja occidentalis pdf free download<br />
-phatak materia medica trillium pendulum to veratrum album pdf free download<br />
-phatak materia medica veratrum viride to zincum valerianicum pdf free download</p>
- <ul>
-<li><strong>Narayana Verlag</strong>: This is a leading publisher and distributor of homeopathic books and journals. You can download the PDF version of the book from their website by clicking on this link: <a href="">Phatak Materia Medica PDF</a>. You will need to register and log in to access the download link.</li>
-<li><strong>HomeopathyBooks.in</strong>: This is a website that offers free homeopathic books and articles for download. You can find the PDF version of the book by searching for "Phatak" in the search box or by clicking on this link: <a href="">Phatak Materia Medica PDF</a>. You can also browse other books by Dr. Phatak and other authors on this website.</li>
-<li><strong>Open Library</strong>: This is a project of the Internet Archive that aims to create a web page for every book ever published. You can borrow the PDF version of the book from their website by clicking on this link: <a href="">Phatak Materia Medica PDF</a>. You will need to sign up and join the waitlist to access the book.</li>
-</ul>
- <p>These are some of the sources where you can download the book for free. However, you should always respect the intellectual property rights of the author and the publisher and use the book for personal and educational purposes only.</p>
- <h2>How to use the book effectively for homeopathic practice and study?</h2>
- <p>Now that you have downloaded the book, you may wonder how to use it effectively for your homeopathic practice and study. Here are some tips and suggestions:</p>
- <h3>The format and structure of the book</h3>
- <p>The book is divided into two parts: Part I contains 318 remedies arranged alphabetically, and Part II contains 686 remedies arranged according to Boger's Synoptic Key. Each remedy has a brief introduction, followed by its keynotes, indications, modalities, relationships, and clinical tips. The keynotes are marked with asterisks (*) to indicate their importance. The indications are given in a systematic order, starting from the mind and ending with the generalities. The modalities are given in brackets after each symptom. The relationships are given in terms of complementary, antidotal, inimical, or similar remedies. The clinical tips are based on the author's personal experience and observation.</p>
- <h3>The key characteristics and indications of the remedies</h3>
- <p>The book gives a clear and concise picture of each remedy, highlighting its key characteristics and indications. You can use the book to learn about the personality, constitution, temperament, miasm, pathology, modalities, and peculiarities of each remedy. You can also use the book to find out which remedy is suitable for which condition, such as acute or chronic diseases, mental or physical complaints, organ or system affections, etc.</p>
- <h3>The comparison and differentiation of similar remedies</h3>
- <p>The book helps you to compare and differentiate similar remedies by giving their relationships and contrasts. You can use the book to understand how one remedy differs from another in terms of symptoms, modalities, causation, aggravation, amelioration, duration, etc. You can also use the book to find out which remedy is more indicated in a given case by analyzing the totality of symptoms and individualizing the patient.</p>
- <h3>The clinical tips and experiences of the author</h3>
- <p>The book also provides valuable clinical tips and experiences of the author that can help you to improve your homeopathic practice and results. You can use the book to learn about the dosage, potency, repetition, antidote, aggravation, accessory measures, etc., of each remedy. You can also use the book to get some practical hints and suggestions on how to manage various cases and situations.</p>
- <h2>What are the advantages and disadvantages of the book?</h2>
- <p>Like any other book, Phatak's Materia Medica has its own advantages and disadvantages. Here are some of them:</p>
- <h3>The pros</h3>
- <ul>
-<li><strong>Concise and comprehensive</strong>: The book covers more than 1000 remedies in a concise and comprehensive manner. It gives all the essential information about each remedy without unnecessary details or repetitions.</ <li><strong>Based on Boger's Synoptic Key</strong>: The book is based on the Synoptic Key of the Materia Medica by Dr. Cyrus Maxwell Boger, which is a logical and systematic method of studying and prescribing remedies. The book follows the same order and classification of symptoms as Boger's Synoptic Key, making it easy to cross-reference and correlate.</li>
-<li><strong>Clinically verified and reliable</strong>: The book is based on the author's clinical experience and observation of more than 50 years. The author has verified and confirmed the efficacy and accuracy of each remedy by using it in his own practice and cases. The book also contains many cured cases and testimonials from the author and his colleagues.</li>
-<li><strong>Easy to read and understand</strong>: The book is written in a simple and clear language, avoiding technical jargon and complex terminology. The book is also well-organized and well-formatted, with headings, subheadings, bullet points, tables, etc., to make it easy to read and understand.</li>
-</ul>
- <h3>The cons</h3>
- <ul>
-<li><strong>Outdated and incomplete</strong>: The book was first published in 1958 and has not been updated or revised since then. The book does not include many new remedies, provings, research, or developments that have emerged in homeopathy in the last few decades. The book also does not cover all the aspects or symptoms of each remedy, leaving out some important or rare ones.</li>
-<li><strong>Lacks sources and references</strong>: The book does not provide any sources or references for the information or data given in it. The book does not mention where the author got his information from, whether from other books, journals, provings, cases, etc. The book also does not cite any authorities or experts to support or validate his statements or opinions.</li>
-<li><strong>No repertory or index</strong>: The book does not have a repertory or an index to help the reader to find or locate a remedy or a symptom quickly or easily. The book only has an alphabetical list of remedies at the beginning of each part, but no other way of searching or browsing the book.</li>
-<li><strong>Poor quality of print and paper</strong>: The book is printed on low-quality paper and ink, which makes it difficult to read and handle. The book is also prone to fading, tearing, staining, or damage over time. The book also has many typographical errors, spelling mistakes, grammatical errors, etc., that affect its readability and credibility.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>Phatak's Materia Medica is a classic homeopathic book that has been used by many practitioners and students for decades. It is a concise and comprehensive materia medica that covers more than 1000 remedies with their keynotes, indications, modalities, relationships, and clinical tips. It is based on Boger's Synoptic Key and the author's clinical experience and observation. It is easy to read and understand and clinically verified and reliable.</p>
- <p>However, the book also has some drawbacks that limit its usefulness and relevance in the modern times. It is outdated and incomplete, lacking many new remedies, provings, research, or developments in homeopathy. It lacks sources and references, repertory or index, and quality of print and paper. It also has many errors and inaccuracies that affect its readability and credibility.</p>
- <p>Therefore, if you want to download this book for free from various sources, you should be aware of its pros and cons and use it with caution and discretion. You should also supplement it with other books, journals, websites, etc., that provide more updated and comprehensive information and guidance on homeopathy and materia medica. You should also cross-check and verify the information and data given in the book with other reliable sources and authorities. You should also consult a qualified and experienced homeopath before using any remedy or advice given in the book.</p>
- <p>We hope this article has given you a brief overview and review of Phatak's Materia Medica and how to download it for free from various sources. If you have any feedback or questions, please feel free to share them with us in the comments section below.</p>
- <h2>FAQs</h2>
- <p>Here are some frequently asked questions about Phatak's Materia Medica and their answers:</p>
- <h3>What is the difference between Phatak's Materia Medica and Boericke's Materia Medica?</h3>
- <p>Boericke's Materia Medica is another classic homeopathic book by Dr. William Boericke, an American homeopath. It was first published in 1901 and has been revised and enlarged several times since then. It covers more than 1400 remedies with their description, action, dosage, tissue affinity, relation to organs and tissues, modalities, relationship, comparison, etc. It also has a repertory at the end of the book.</p>
- <p>The main difference between Phatak's Materia Medica and Boericke's Materia Medica is that Phatak's book is based on Boger's Synoptic Key, while Boericke's book is based on Hahnemann's Organon. Phatak's book gives more emphasis on the keynotes, indications, modalities, and relationships of the remedies, while Boericke's book gives more emphasis on the description, action, dosage, tissue affinity, relation to organs and tissues, etc., of the remedies. Phatak's book is more concise and comprehensive, while Boericke's book is more detailed and descriptive.</p>
- <h3>What are some other books by Dr. S.R. Phatak?</h3>
- <p>Some other books by Dr. S.R. Phatak are:</p>
- <ul>
-<li><em>Concise Repertory of Homoeopathic Medicines</em>: This is a repertory based on Boger's Synoptic Key and Kent's Repertory. It covers more than 2000 rubrics with their remedies in a concise and logical manner.</li>
-<li><em>A Brief Study Course in Homoeopathy</em>: This is a book that covers the basic principles and practice of homeopathy in a simple and clear language. It covers topics such as philosophy, organon, case taking, potency selection, materia medica, therapeutics, etc.</li>
-<li><em>Homoeopathy: Its Fundamentals & Treatment</em>: This is a book that explains the fundamentals of homeopathy and its treatment of various diseases in a systematic and scientific way. It covers topics such as history, principles, laws, miasms, constitution, susceptibility, diagnosis, prognosis, etc.</li>
-<li><em>Homoeopathic Case Taking</em>: This is a book that guides the reader on how to take a proper homeopathic case history from the patient. It covers topics such as general rules, mental symptoms, physical symptoms, modalities, concomitants, causation, etc.</li>
-</ul>
- <h3>How can I learn more about homeopathy and materia medica?</h3>
- <p>If you want to learn more about homeopathy and materia medica, you can do the following:</p>
- <ul>
-<li><strong>Read books</strong>: You can read books by various authors on different aspects of homeopathy and materia medica. Some of the recommended authors are Hahnemann, Kent, Boger, Allen, Hering, Clarke, Boericke, Phatak, Vithoulkas, Sankaran, Scholten, etc. You can find many free homeopathic books online or buy them from various sources.</li>
-<li><strong>Watch videos</strong>: You can watch videos by various homeopaths and teachers on different topics of homeopathy and materia medica. Some of the recommended channels are Homeopathy 360, Homeopathic World Community, Homeopathy Academy, Homeopathy School International, etc. You can find many free homeopathic videos on YouTube or other platforms.</li>
-<li><strong>Listen to podcasts</strong>: You can listen to podcasts by various homeopaths and experts on different aspects of homeopathy and materia medica. Some of the recommended podcasts are Homeopathy Hangout, Homeopathy Radio, Homeopathy Rocks, Homeopathy One, etc. You can find many free homeopathic podcasts on Spotify, Apple Podcasts, Google Podcasts, etc.</li>
-<li><strong>Join courses</strong>: You can join courses by various institutions and organizations that offer online or offline education and training in homeopathy and materia medica. Some of the recommended courses are The School of Homeopathy, The Other Song Academy, The International Academy of Classical Homeopathy, The British Institute of Homeopathy, etc. You can find many free or paid homeopathic courses on their websites or other platforms.</li>
-<li><strong>Consult a homeopath</strong>: You can consult a qualified and experienced homeopath who can guide you and teach you more about homeopathy and materia medica. You can find a homeopath near you or online by searching on various directories or websites.</li>
-</ul>
- <h3>Where can I find other free homeopathic books online?</h3>
- <p>If you are looking for other free homeopathic books online, you can visit the following websites:</p>
- <ul>
-<li><strong>Homeoint.org</strong>: This is a website that offers a large collection of free homeopathic books in various languages. You can browse the books by author, title, category, or language. You can also download the books in PDF or HTML format.</li>
-<li><strong>Hpathy.com</strong>: This is a website that offers a wide range of free homeopathic resources, including books, articles, journals, cases, videos, etc. You can browse the books by author or title. You can also download the books in PDF format.</li>
-<li><strong>Homeorizon.com</strong>: This is a website that offers a variety of free homeopathic materials, such as books, articles, lectures, seminars, webinars, etc. You can browse the books by author or title. You can also download the books in PDF format.</li>
-<li><strong>Simillimum.com</strong>: This is a website that offers a number of free homeopathic publications such as books, journals, newsletters, magazines, etc. You can browse the books by author or title. You can also download the books in PDF format.</li>
-</ul>
- <h3>How can I contact Dr. S.R. Phatak or his publisher?</h3>
- <p>If you want to contact Dr. S.R. Phatak or his publisher, you can try the following ways:</p>
- <ul>
-<li><strong>Email</strong>: You can send an email to Dr. S.R. Phatak's son, Dr. Rajesh Phatak, who is also a homeopath and a writer, at <a href="mailto:rajeshphatak@hotmail.com">rajeshphatak@hotmail.com</a>. You can also send an email to his publisher, B. Jain Publishers Pvt. Ltd., at <a href="mailto:info@bjain.com">info@bjain.com</a>.</li>
-<li><strong>Phone</strong>: You can call Dr. Rajesh Phatak at +91-9820123456 or his publisher at +91-11-4567 1000.</li>
-<li><strong>Address</strong>: You can write a letter to Dr. Rajesh Phatak at 123, ABC Road, Mumbai - 400001, India or his publisher at B-1/41, Ashok Vihar Phase II, Delhi - 110052, India.</li>
-<li><strong>Website</strong>: You can visit Dr. Rajesh Phatak's website at <a href="">www.drphatak.com</a> or his publisher's website at <a href="">www.bjainbooks.com</a>.</li>
-</ul></p> 401be4b1e0<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Get More Screen Space with Hide Bar APK - The App that Hides the Navigation Bar.md b/spaces/congsaPfin/Manga-OCR/logs/Get More Screen Space with Hide Bar APK - The App that Hides the Navigation Bar.md
deleted file mode 100644
index 8457404c5cc76e69bcad0afe2c70510c08043ebd..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Get More Screen Space with Hide Bar APK - The App that Hides the Navigation Bar.md	
+++ /dev/null
@@ -1,115 +0,0 @@
-
-<h1>How to Hide the Navigation Bar on Your Android Device</h1>
-<p>Do you want to get rid of the annoying navigation bar at the bottom of your screen? Do you want to enjoy more screen space and less distractions on your Android device? If yes, then this article is for you.</p>
-<h2>hide bar apk</h2><br /><p><b><b>Download Zip</b> &#10040; <a href="https://urlca.com/2uOfWv">https://urlca.com/2uOfWv</a></b></p><br /><br />
-<p>In this article, we will show you how to hide the navigation bar on your Android device using two methods: using settings and using an app. We will also explain what is the navigation bar and why you might want to hide it.</p>
-<h2>What is the navigation bar and why hide it?</h2>
-<h3>The navigation bar is the strip of buttons at the bottom of your screen that lets you go back, home, or switch apps.</h3>
-<p>The navigation bar is one of the essential features of Android that allows you to navigate your device easily. However, it also takes up some valuable screen space and can interfere with your user experience.</p>
-<h3>Some reasons to hide the navigation bar are:</h3>
-<h4>To get more screen space for your apps and content.</h4>
-<p>By hiding the navigation bar, you can make use of every inch of your screen and enjoy a more immersive and full-screen experience. This can be especially useful for watching videos, playing games, or reading books.</p>
-<h4>To prevent accidental taps or gestures on the navigation bar.</h4>
-<p>Sometimes, you might accidentally touch or swipe on the navigation bar and interrupt what you are doing on your device. This can be frustrating and annoying, especially if you are in a critical moment of a game or a video call. By hiding the navigation bar, you can avoid these mishaps and have more control over your device.</p>
-<h4>To customize the look and feel of your device.</h4>
-<p>If you are bored with the default appearance of your device, hiding the navigation bar can give it a fresh and new look. You can also choose different themes, colors, or icons for your navigation buttons or gestures if you use an app to hide the navigation bar.</p>
-<h2>How to hide the navigation bar using settings?</h2>
-<h3>Some devices have a built-in option to hide the navigation bar in the settings menu.</h3>
-<p>If you have a device that runs on Android 9 Pie or later, you might have a native option to hide the navigation bar in your settings. This option allows you to use gestures instead of buttons to navigate your device.</p>
-<p>hide navigation bar apk<br />
-hide nav bar apk<br />
-hide status bar apk<br />
-hide system bar apk<br />
-hide navigation bar android apk<br />
-hide nav bar android apk<br />
-hide status bar android apk<br />
-hide system bar android apk<br />
-hide navigation bar app apk<br />
-hide nav bar app apk<br />
-hide status bar app apk<br />
-hide system bar app apk<br />
-hide navigation bar pro apk<br />
-hide nav bar pro apk<br />
-hide status bar pro apk<br />
-hide system bar pro apk<br />
-hide navigation bar no root apk<br />
-hide nav bar no root apk<br />
-hide status bar no root apk<br />
-hide system bar no root apk<br />
-hide navigation bar full screen apk<br />
-hide nav bar full screen apk<br />
-hide status bar full screen apk<br />
-hide system bar full screen apk<br />
-hide navigation bar gesture apk<br />
-hide nav bar gesture apk<br />
-hide status bar gesture apk<br />
-hide system bar gesture apk<br />
-download hide navigation bar apk<br />
-download hide nav bar apk<br />
-download hide status bar apk<br />
-download hide system bar apk<br />
-install hide navigation bar apk<br />
-install hide nav bar apk<br />
-install hide status bar apk<br />
-install hide system bar apk<br />
-how to use hide navigation bar apk<br />
-how to use hide nav bar apk<br />
-how to use hide status bar apk<br />
-how to use hide system bar apk<br />
-how to get rid of navigation bar with apk <br />
-how to get rid of nav bar with apk <br />
-how to get rid of status bar with apk <br />
-how to get rid of system bar with apk <br />
-best app to hide navigation bar with apk <br />
-best app to hide nav bar with apk <br />
-best app to hide status bar with apk <br />
-best app to hide system bar with apk</p>
-<h3>Here are the steps to hide the navigation bar using settings:</h3>
-<h4>Go to Settings > Display > Navigation bar.</h4> <h4>Choose the option to hide the navigation bar or use gestures instead of buttons.</h4>
-<p>You can choose between three types of navigation gestures: swipe up from the bottom, swipe up and hold, or swipe from the sides and bottom. Each gesture corresponds to a different navigation action: back, home, or recent apps.</p>
-<h4>When the navigation bar is hidden, you can swipe up from the bottom edge of the screen to show it temporarily.</h4>
-<p>If you need to access the navigation bar for some reason, you can swipe up from the bottom edge of the screen and it will appear for a few seconds. You can also swipe down from the top edge of the screen to access the notification panel and quick settings.</p>
-<h2>How to hide the navigation bar using an app?</h2>
-<h3>If your device does not have a built-in option to hide the navigation bar, you can use an app to do it.</h3>
-<p>There are many apps that can help you hide the navigation bar on your Android device. Some of them require root access, while others do not. One of the apps that does not require root access and works well on most devices is Hide Navigation Bar APK.</p>
-<h3>One of the apps that can hide the navigation bar is Hide Navigation Bar APK.</h3>
-<p>Hide Navigation Bar APK is a simple and lightweight app that lets you hide the navigation bar on your Android device. It does not require root access or any complicated settings. It also has some useful features and customization options that make it a great choice for hiding the navigation bar.</p>
-<h3>Here are the steps to hide the navigation bar using Hide Navigation Bar APK:</h3>
-<h4>Download and install Hide Navigation Bar APK from [here].</h4>
-<p>The first step is to download and install Hide Navigation Bar APK from its official website . You can also scan the QR code below to download it directly to your device. Make sure you enable unknown sources in your security settings before installing the app.</p>
- <img src="^3^" alt="QR code for Hide Navigation Bar APK">
- <h4>Grant the app permission to access your device settings and draw over other apps.</h4>
-<p>The next step is to grant the app permission to access your device settings and draw over other apps. This is necessary for the app to work properly and hide the navigation bar. You can do this by following the instructions on the app's welcome screen or by going to Settings > Apps > Hide Navigation Bar > Permissions.</p>
-<h4>Tap on the toggle button to enable or disable hiding the navigation bar.</h4>
-<p>The final step is to tap on the toggle button on the app's main screen to enable or disable hiding the navigation bar. You can also tap on the notification icon to quickly switch between hiding and showing the navigation bar. When the navigation bar is hidden, you can use gestures or shortcuts to navigate your device.</p>
-<h4>You can also customize the hiding mode, trigger area, and animation in the app settings.</h4>
-<p>If you want to customize how the app hides the navigation bar, you can go to the app settings and change some options. You can choose between three hiding modes: immersive, sticky immersive, or lean back. You can also adjust the size and position of the trigger area that shows or hides the navigation bar. You can also enable or disable animation effects when hiding or showing the navigation bar.</p>
- <h2>Conclusion</h2>
-<p>Hiding the navigation bar on your Android device can be a great way to improve your user experience and customize your device. You can do it using settings or using an app like Hide Navigation Bar APK. We hope this article helped you learn how to hide the navigation bar on your Android device easily and effectively.</p>
- <h2>FAQs</h2>
-<h3>What are some benefits of hiding the navigation bar?</h3>
-<p>Some benefits of hiding the navigation bar are:</p>
-<ul>
-<li>You get more screen space for your apps and content.</li>
-<li>You prevent accidental taps or gestures on the navigation bar.</li>
-<li>You customize the look and feel of your device.</li>
-</ul>
- <h3>What are some drawbacks of hiding the navigation bar?</h3>
-<p>Some drawbacks of hiding the navigation bar are:</p>
-<ul>
-<li>You might need some time to get used to using gestures or shortcuts instead of buttons.</li>
-<li>You might encounter some compatibility issues with some apps that rely on the navigation bar.</li>
-<li>You might lose some functionality or accessibility features that depend on the navigation bar.</li>
-</ul>
- <h3>How do I restore the navigation bar if I want it back?</h3>
-<p>If you want to restore the navigation bar, you can do it by either:</p>
-<ul>
-<li>Disabling hiding mode in settings if you used the settings option to hide the navigation bar.</li>
-<li>Turning off the toggle button in Hide Navigation Bar APK if you used the app to hide the navigation bar.</li>
-</ul>
- <h3>Is hiding the navigation bar safe and legal?</h3>
-<p>Hiding the navigation bar is safe and legal as long as you use a trusted app or method to do it. You are not violating any terms of service or warranty by hiding the navigation bar. However, you should be careful about downloading and installing apps from unknown sources or granting permissions to apps that you do not trust.</p>
- <h3>Can I hide the navigation bar on any Android device?</h3>
-<p>You can hide the navigation bar on most Android devices that run on Android 4.4 KitKat or later. However, some devices may have different settings or options to hide the navigation bar, or may not support hiding the navigation bar at all. You should check your device's specifications and compatibility before trying to hide the navigation bar.</p> 401be4b1e0<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Heroes Strike Offline A Perfect Balance of Strategy and Action.md b/spaces/congsaPfin/Manga-OCR/logs/Heroes Strike Offline A Perfect Balance of Strategy and Action.md
deleted file mode 100644
index 1135eee63e476974cb0b5ef8c8bf752e538f861b..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Heroes Strike Offline A Perfect Balance of Strategy and Action.md	
+++ /dev/null
@@ -1,107 +0,0 @@
-<br />
-<h1>Heroes Strike Offline: A Fun and Free MOBA Game Without Internet</h1>
- <h2>Introduction</h2>
-<p>Do you love playing MOBA games but hate the lag, the toxic players, and the expensive in-app purchases? If you are looking for a free, fun, and offline MOBA game, then you should check out Heroes Strike Offline. This game is developed by Wolffun Pte Ltd and is available for both Android and iOS devices. In this article, we will review the features, gameplay, graphics, and modes of Heroes Strike Offline and tell you why it is one of the best MOBA games out there.</p>
- <h2>What is Heroes Strike Offline?</h2>
-<p>Heroes Strike Offline is a MOBA game that does not require internet connection to play. It has modern and trending game modes, such as 3v3 Modern MOBA, Battle Royale 12 players, Game of King with 8 players, and many more. It also has a huge collection of heroes, each with unique abilities and skills. You can equip your hero with two skills of your choice, besides the main hero ability, to create your own strategy and style. The game has a 4-minute short match system, which is ideal for on-the-go gaming. You can also earn generous rewards and easy progression as you play the game.</p>
-<h2>heroes strike offline</h2><br /><p><b><b>DOWNLOAD</b> &middot; <a href="https://urlca.com/2uO90F">https://urlca.com/2uO90F</a></b></p><br /><br />
- <h2>What are the features of Heroes Strike Offline?</h2>
-<p>Heroes Strike Offline has many features that make it a great MOBA game. Some of them are:</p>
-<ul>
-<li><h3>A fair and skill-based game</h3>
-<p>The game is designed to be fair and balanced for all players. There is no pay-to-win system or unfair matchmaking. The game is all about your skill and strategy. You can choose from different heroes and skills to suit your preference and playstyle. You can also practice your skills in the offline mode against AI opponents.</p></li>
-<li><h3>A variety of game modes</h3>
-<p>The game has different game modes to keep you entertained and challenged. You can play the classic 3v3 Modern MOBA mode, where you have to destroy the enemy base while defending your own. You can also play the Battle Royale mode, where you have to survive against 11 other players in a shrinking map. You can also try the Game of King mode, where you have to capture and hold the throne for as long as possible. And there are many more modes that are updated monthly.</p></li>
-<li><h3>A large collection of heroes</h3>
-<p>The game has over 100 heroes to choose from, each with their own signature attacks and abilities. You can find heroes from different classes, such as fighter, tank, mage, assassin, support, and marksman. You can also customize your hero with different skins and accessories.</p></li>
-<li><h3>A simple and smooth control system</h3>
-<p>The game has a simple and intuitive control system that makes it easy to play. You can move your hero with a virtual joystick on the left side of the screen and use your skills with buttons on the right side. You can also adjust the sensitivity and layout of the controls according to your preference.</p></li>
-<li><h3>A stunning and colorful graphics</h3>
-<p>The game has a stunning and colorful graphics that make it appealing and enjoyable to play. The game has a cartoonish and stylized art style that suits the theme and mood of the game. The game also has smooth animations and effects that enhance the gameplay experience.</p></li>
-</ul>
- <h2>How to download and install Heroes Strike Offline?</h2>
-<p>If you want to download and install Heroes Strike Offline on your device, you can follow these simple steps:</p>
-<p>heroes strike offline mod apk<br />
-heroes strike offline best hero<br />
-heroes strike offline cheats<br />
-heroes strike offline download<br />
-heroes strike offline hack<br />
-heroes strike offline gameplay<br />
-heroes strike offline review<br />
-heroes strike offline tips and tricks<br />
-heroes strike offline unlimited money<br />
-heroes strike offline latest version<br />
-heroes strike offline ios<br />
-heroes strike offline pc<br />
-heroes strike offline online mode<br />
-heroes strike offline how to play<br />
-heroes strike offline guide<br />
-heroes strike offline characters<br />
-heroes strike offline skins<br />
-heroes strike offline codes<br />
-heroes strike offline update<br />
-heroes strike offline wiki<br />
-heroes strike offline reddit<br />
-heroes strike offline discord<br />
-heroes strike offline ranking<br />
-heroes strike offline tier list<br />
-heroes strike offline controller support<br />
-heroes strike offline moba & battle royale<br />
-heroes strike offline game of king mode<br />
-heroes strike offline 3v3 modern moba mode<br />
-heroes strike offline 12 players battle royale mode<br />
-heroes strike offline free gems and coins<br />
-heroes strike offline no internet required<br />
-heroes strike offline lag free servers<br />
-heroes strike offline fun events and rewards<br />
-heroes strike offline balanced characters and skills<br />
-heroes strike offline new content and features monthly<br />
-heroes strike offline esport spirit game<br />
-heroes strike offline wolffun pte ltd developer<br />
-heroes strike offline strategy casual game genre<br />
-heroes strike offline stylized graphics and animation<br />
-heroes strike offline smooth gameplay and easy UI <br />
-heroes strike offline equip your hero with 2 skills of choice <br />
-heroes strike offline 4-minute short match ideal for on-the-go gaming <br />
-heroes strike offline huge collection of heroes each with signature attacks and abilities <br />
-heroes strike offline multiple choices of skills in many types attack defense stun support <br />
-heroes strike offline designed for freebies all items made accessible for free <br />
-heroes strike offline unique moba combat style with a perfect balance between fun and depth <br />
-heroes strike offline solid heroes in each class plus 5 different skills to begin with <br />
-heroes strike offline generous reward easy progression <br />
-heroes strike offline climb up the league with your allies and tactics</p>
-<ol>
-<li><h4>For Android devices</h4>
-<ul>
-<li>Go to the Google Play Store app on your device or click [here](^1^) to open it on your browser.</li>
-<li>Search for Heroes Strike Offline or tap on this [link](^1^) to go directly to the game page.</li>
-<li>Tap on the Install button and wait for the download to finish.</li>
-<li>Once the download is complete, tap on the Open button or find the game icon on your home screen or app drawer.</li>
-<li>Enjoy playing Heroes Strike Offline!</li>
-</ul></li>
-<li><h4>For iOS devices</h4>
-<ul>
-<li>Go to the App Store app on your device or click [here](^2^) to open it on your browser.</li>
-<li>Search for Heroes Strike Offline or tap on this [link](^2^) to go directly to the game page.</li>
-<li>Tap on the Get button and wait for the download to finish.</li>
-<li>Once the download is complete, tap on the Open button or find the game icon on your home screen or app drawer.</li>
-<li>Enjoy playing Heroes Strike Offline!</li>
-</ul></li>
-</ol>
- <h2>Conclusion</h2>
-<p>Heroes Strike Offline is a fun and free MOBA game that you can play without internet connection. It has many features that make it a great game, such as a fair and skill-based gameplay, a variety of game modes, a large collection of heroes, a simple and smooth control system, and a stunning and colorful graphics. If you are a fan of MOBA games, you should definitely give Heroes Strike Offline a try. You will not regret it!</p>
- <h2>FAQs</h2>
-<ul>
-<li><h3>What are the system requirements for Heroes Strike Offline?</h3>
-<p>The game requires Android 4.4 or higher or iOS 10.0 or higher to run. It also requires at least 200 MB of free storage space on your device.</p></li>
-<li><h3>How can I get more coins and gems in Heroes Strike Offline?</h3>
-<p>You can get more coins and gems by playing the game regularly and completing missions and achievements. You can also watch ads or use real money to buy them from the shop.</p></li>
-<li><h3>How can I unlock more heroes and skills in Heroes Strike Offline?</h3>
-<p>You can unlock more heroes and skills by using coins or gems to buy them from the shop. You can also get them from chests or events.</p></li>
-<li><h3>How can I play with my friends in Heroes Strike Offline?</h3>
-<p>You can play with your friends in Heroes Strike Offline by using the local multiplayer mode. You and your friends need to be connected to the same Wi-Fi network and then join the same room code. You can also invite your friends to join your room by sharing the code with them.</p></li>
-<li><h3>How can I contact the developers of Heroes Strike Offline?</h3>
-<p>You can contact the developers of Heroes Strike Offline by sending them an email at support@wolffun.net or by visiting their Facebook page at https://www.facebook.com/HeroesStrikeOffline/.</p></li>
-</ul></p> 197e85843d<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/How to Unlock All Servers with UFO VPN APK 4.0 (No Ads No Root).md b/spaces/congsaPfin/Manga-OCR/logs/How to Unlock All Servers with UFO VPN APK 4.0 (No Ads No Root).md
deleted file mode 100644
index 6e6a344eb555b535af0dfa9358f0fb1082272e69..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/How to Unlock All Servers with UFO VPN APK 4.0 (No Ads No Root).md	
+++ /dev/null
@@ -1,94 +0,0 @@
-<br />
-<h1>UFO VPN APK 4.0: A Fast and Secure VPN Service for Android</h1>
-<p>Do you want to access blocked websites, apps, and streaming services on your Android device? Do you want to protect your online privacy and security from hackers, trackers, and ISPs? Do you want to enjoy a fast and stable internet connection with no bandwidth limits? If you answered yes to any of these questions, then you need a reliable VPN service like UFO VPN.</p>
-<h2>ufo vpn apk 4.0</h2><br /><p><b><b>Download Zip</b> &#10001; <a href="https://urlca.com/2uO7MO">https://urlca.com/2uO7MO</a></b></p><br /><br />
-<h2>What is UFO VPN?</h2>
-<p>UFO VPN is a popular VPN service that provides you with a secure and encrypted tunnel to the internet. It allows you to bypass geo-restrictions, censorship, and firewalls, and access any content you want from anywhere in the world. It also protects your online identity and data from prying eyes, and enhances your online experience with fast and smooth performance.</p>
-<h3>Features of UFO VPN</h3>
-<p>UFO VPN has many features that make it stand out from other VPN services. Here are some of them:</p>
-<h4>Lightening fast speed</h4>
-<p>UFO VPN has over 2000 servers in more than 50 countries, which means you can always find a server that suits your needs. You can enjoy lightening fast speed with UFO's five-star service, whether you are browsing, streaming, gaming, or downloading.</p>
-<h4>Bank-grade security</h4>
-<p>UFO VPN uses top-level bank-grade security and AES 256-bit encryption to keep your activity away from any third parties. It also has a strict no-log policy, which means it does not collect or store any of your personal information or online activity. You can surf the web with peace of mind knowing that your privacy is protected.</p>
-<p>ufo vpn mod apk 4.0.8 premium unlocked<br />
-ufo vpn apk 4.0 download for android<br />
-ufo vpn 4.0 apk free download latest version<br />
-ufo vpn premium apk 4.0 mod unlocked<br />
-ufo vpn apk 4.0 no ads fast proxy<br />
-ufo vpn 4.0 apk download for pc<br />
-ufo vpn premium mod apk 4.0 latest<br />
-ufo vpn apk 4.0 unlimited bandwidth<br />
-ufo vpn 4.0 apk free download for firestick<br />
-ufo vpn premium apk 4.0 cracked<br />
-ufo vpn apk 4.0 best free proxy<br />
-ufo vpn 4.0 apk download for ios<br />
-ufo vpn premium mod apk 4.0 update<br />
-ufo vpn apk 4.0 secure wifi hotspot<br />
-ufo vpn 4.0 apk free download for windows<br />
-ufo vpn premium apk 4.0 hack<br />
-ufo vpn apk 4.0 fast servers worldwide<br />
-ufo vpn 4.0 apk download for mac<br />
-ufo vpn premium mod apk 4.0 old version<br />
-ufo vpn apk 4.0 bypass geo-restrictions<br />
-ufo vpn 4.0 apk free download for chromebook<br />
-ufo vpn premium apk 4.0 patched<br />
-ufo vpn apk 4.0 stream online videos<br />
-ufo vpn 4.0 apk download for linux<br />
-ufo vpn premium mod apk 4.0 new features<br />
-ufo vpn apk 4.0 protect your privacy<br />
-ufo vpn 4.0 apk free download for smart tv<br />
-ufo vpn premium apk 4.0 full version<br />
-ufo vpn apk 4.0 access blocked websites<br />
-ufo vpn 4.0 apk download for roku<br />
-ufo vpn premium mod apk 4.0 review<br />
-ufo vpn apk 4.0 easy to use interface<br />
-ufo vpn 4.0 apk free download for kodi<br />
-ufo vpn premium apk 4.0 pro features<br />
-ufo vpn apk 4.0 support multiple devices<br />
-ufo vpn 4.0 apk download for xbox one<br />
-ufo vpn premium mod apk 4.0 bug fixes<br />
-ufo vpn apk 4.0 high speed connection<br />
-ufo vpn 4.0 apk free download for ps4<br />
-ufo vpn premium apk 4.0 original file</p>
-<h4>Up to 5 devices</h4>
-<p>UFO VPN allows you to connect up to 5 devices under one account. You can use it on your Android phone, tablet, laptop, desktop, or smart TV. You can also share it with your family or friends and enjoy the VPN service together.</p>
-<h4>Money-back guarantee</h4>
-<p>UFO VPN offers a 30-day money-back guarantee for its premium users. If you are not satisfied with the service for any reason, you can request a full refund within 30 days of purchase. You can also try the free version of UFO VPN before upgrading to the premium version.</p>
-<h2>How to download and install UFO VPN APK 4.0 on your Android device</h2>
-<p>If you want to use UFO VPN on your Android device, you need to download and install the UFO VPN APK 4.0 file from the official website of UFO VPN. Here are the steps to do so:</p>
-<h3>Step 1: Go to the official website of UFO VPN</h3>
-<p>You can visit [the official website of UFO VPN](^1^) from your Android device's browser. You will see a download button for Android on the homepage.</p>
-<h3>Step 2: Tap on the download button for Android</h3>
-<p>You will be redirected to a page where you can download the UFO VPN APK 4.0 file. Tap on the download button and wait for the file to be downloaded <h3>Step 3: Allow unknown sources on your device settings</h3>
-<p>Before you can install the UFO VPN APK 4.0 file, you need to enable the installation of apps from unknown sources on your device settings. To do this, go to Settings > Security > Unknown Sources and toggle it on. You may see a warning message, but you can ignore it and tap on OK.</p>
-<h3>Step 4: Open the downloaded file and install it</h3>
-<p>Once you have downloaded the UFO VPN APK 4.0 file, you can find it in your Downloads folder or your notification bar. Tap on the file and follow the instructions to install it on your device. You may need to grant some permissions to the app during the installation process.</p>
-<h3>Step 5: Launch the app and sign up or log in</h3>
-<p>After you have installed the UFO VPN APK 4.0 file, you can launch the app from your app drawer or home screen. You will see a welcome screen where you can sign up for a new account or log in with your existing account. If you don't have an account yet, you can create one for free by entering your email and password. You can also use your Facebook or Google account to sign up or log in.</p>
-<h2>How to use UFO VPN APK 4.0 on your Android device</h2>
-<p>Using UFO VPN APK 4.0 on your Android device is very easy and intuitive. Here are the steps to do so:</p>
-<h3>Choose a server location from the list or use the smart location feature</h3>
-<p>When you open the app, you will see a list of server locations that you can choose from. You can scroll down the list and tap on any server that you want to connect to. You can also use the search bar to find a specific country or region. Alternatively, you can use the smart location feature, which will automatically select the best server for you based on your location and network conditions.</p>
-<h3>Tap on the connect button and enjoy the VPN service</h3>
-<p>Once you have selected a server location, you can tap on the connect button at the bottom of the screen. You will see a green icon indicating that you are connected to the VPN service. You can now access any website, app, or streaming service that you want without any restrictions or interference.</p>
-<h3>Customize your settings and preferences according to your needs</h3>
-<p>You can also customize your settings and preferences according to your needs by tapping on the menu icon at the top left corner of the screen. You can access various options such as protocol, kill switch, split tunneling, DNS leak protection, and more. You can also check your account details, subscription status, and customer support.</p>
-<h2>Conclusion</h2>
-<p>UFO VPN APK 4.0 is a fast and secure VPN service for Android devices that allows you to access any content you want from anywhere in the world. It also protects your online privacy and security from hackers, trackers, and ISPs. It has many features that make it stand out from other VPN services, such as lightening fast speed, bank-grade security, up to 5 devices, and money-back guarantee. You can download and install UFO VPN APK 4.0 on your Android device by following the simple steps above. You can also use UFO VPN APK 4.0 on your Android device by choosing a server location, tapping on the connect button, and customizing your settings and preferences according to your needs.</p>
-<h2>FAQs</h2>
-<p>Here are some frequently asked questions about UFO VPN APK 4.0:</p>
-<ul>
-<li><b>Is UFO VPN APK 4.0 safe to use?</b></li>
-<p>Yes, UFO VPN APK 4.0 is safe to use as it uses top-level bank-grade security and AES 256-bit encryption to protect your online activity from any third parties. It also has a strict no-log policy, which means it does not collect or store any of your personal information or online activity.</p>
-<li><b>Is UFO VPN APK 4.0 free to use?</b></li>
-<p>UFO VPN APK 4.0 has a free version that you can use with some limitations, such as fewer servers, lower speed, and ads. If you want to enjoy the full features of UFO VPN APK 4.0, you need to upgrade to the premium version, which costs $6.99 per month or $29.99 per year.</p>
-<li><b>Does UFO VPN APK 4.0 work with Netflix?</b></li>
-<p>Yes, UFO VPN APK 4.0 works with Netflix and other streaming services such as Hulu, BBC iPlayer, Disney+, Amazon Prime Video, and more . You can also switch between different Netflix regions by choosing a server location from the list.</p>
-<li><b>Does UFO VPN APK 4.0 have a kill switch?</b></li>
-<p>Yes, UFO VPN APK 4.0 has a kill switch feature that automatically disconnects your internet connection if the VPN connection drops. This prevents your online activity from being exposed to any third parties. You can enable or disable the kill switch feature from the settings menu.</p>
-<li><b>How can I contact UFO VPN APK 4.0 customer support?</b></li>
-<p>You can contact UFO VPN APK 4.0 customer support by tapping on the menu icon at the top left corner of the screen and choosing the support option. You can also visit [the official website of UFO VPN] and use the live chat or email support options.</p>
-</ul>
-<p>I hope you enjoyed reading this article and learned something new about UFO VPN APK 4.0. If you have any questions or feedback, please feel free to leave a comment below. Thank you for your time and attention.</p> 401be4b1e0<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/RPP 1 Lembar Kelas 5 Tema 1 Kurikulum 2013 Revisi 20212022 Perangkat Pembelajaran Lengkap dan Praktis.md b/spaces/congsaPfin/Manga-OCR/logs/RPP 1 Lembar Kelas 5 Tema 1 Kurikulum 2013 Revisi 20212022 Perangkat Pembelajaran Lengkap dan Praktis.md
deleted file mode 100644
index 411b27b29c61938f1a41e2a7676ed7bf1312f149..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/RPP 1 Lembar Kelas 5 Tema 1 Kurikulum 2013 Revisi 20212022 Perangkat Pembelajaran Lengkap dan Praktis.md	
+++ /dev/null
@@ -1,180 +0,0 @@
-<br />
-<h1>Download RPP 1 Lembar Kelas 5 Tema 1 K13 Revisi 2021/2022</h1>
- <p>If you are a teacher of grade 5 in elementary school, you might be looking for a way to download RPP 1 Lembar Kelas 5 Tema 1, which is the latest format of lesson plan for the first theme of the curriculum. In this article, we will explain what RPP 1 Lembar is, why it is beneficial, what challenges it poses, and how to download and use it effectively.</p>
-<h2>download rpp 1 lembar kelas 5 tema 1</h2><br /><p><b><b>Download Zip</b> &#11088; <a href="https://urlca.com/2uObRI">https://urlca.com/2uObRI</a></b></p><br /><br />
- <h2>What is RPP 1 Lembar?</h2>
- <p>RPP stands for Rencana Pelaksanaan Pembelajaran, which means lesson plan in Indonesian. It is a document that contains the objectives, activities, and assessment of a learning process. RPP is based on the syllabus and the curriculum, which for grade 5 in elementary school is Kurikulum 2013 (K13).</p>
- <p>RPP 1 Lembar is a simplified format of RPP that only consists of one page. It was introduced by the Ministry of Education, Culture, Research and Technology in 2019 as part of the "Merdeka Belajar" program, which aims to reduce the administrative burden of teachers and give them more freedom and creativity in teaching. RPP 1 Lembar only has three components: learning objectives, learning activities, and assessment.</p>
- <h3>The benefits of RPP 1 Lembar</h3>
- <p>Some of the benefits of using RPP 1 Lembar are:</p>
- <ul>
-<li>It saves time and energy for teachers, as they do not have to write lengthy and detailed lesson plans.</li>
-<li>It allows teachers to focus more on the quality and effectiveness of the learning process, rather than on the formality and bureaucracy.</li>
-<li>It encourages teachers to be more innovative and flexible in designing and implementing learning activities that suit the needs and interests of their students.</li>
-<li>It supports the development of students' higher-order thinking skills, such as critical thinking, problem-solving, creativity, and collaboration.</li>
-</ul>
- <h3>The challenges of RPP 1 Lembar</h3>
- <p>Some of the challenges that teachers might face when using RPP 1 Lembar are:</p>
-<p>Download RPP 1 Lembar Lengkap Kelas 5 SD Tema 1 Semester 1 Revisi 2020/2021<br />
-Download RPP Daring 1 Lembar Kelas 5 Tema 1 Kurikulum 2013 Revisi Terbaru<br />
-Download RPP 1 Lembar Kelas 5 Tema 1 K13 Revisi 2021/2022<br />
-Download RPP Satu Lembar Kelas 5 SD Tema 1 Subtema 1 Pembelajaran 1<br />
-Download RPP Online 1 Lembar Kelas 5 Tema 1 Subtema 2 Pembelajaran 2<br />
-Download RPP Format Baru 1 Lembar Kelas 5 Tema 1 Subtema 3 Pembelajaran 3<br />
-Download RPP Penyederhanaan 1 Lembar Kelas 5 Tema 1 Subtema 4 Pembelajaran 4<br />
-Download RPP Kurikulum Nasional (K-NAS) Kelas V Tema I Semester Ganjil<br />
-Download RPP K13 Edisi Terbaru Kelas Lima Tema Pertama Subtema Pertama<br />
-Download RPP K13 Edisi Revisi Kelas Lima Tema Pertama Subtema Kedua<br />
-Download RPP K13 Edisi Update Kelas Lima Tema Pertama Subtema Ketiga<br />
-Download RPP K13 Edisi Perbaikan Kelas Lima Tema Pertama Subtema Keempat<br />
-Download RPP K13 Edisi Penyesuaian Kelas Lima Tema Pertama Semua Pembelajaran<br />
-Download RPP K13 Edisi Pemutakhiran Kelas Lima Tema Pertama Lengkap dengan Silabus<br />
-Download RPP K13 Edisi Peningkatan Kelas Lima Tema Pertama Lengkap dengan Prota dan Promes<br />
-Download Contoh RPP K13 Terbaru Kelas V Tema Satu Lengkap dengan KD dan Indikator<br />
-Download Contoh RPP K13 Terbaik Kelas V Tema Satu Lengkap dengan Tujuan dan Materi<br />
-Download Contoh RPP K13 Berkualitas Kelas V Tema Satu Lengkap dengan Model dan Metode<br />
-Download Contoh RPP K13 Bervariasi Kelas V Tema Satu Lengkap dengan Media dan Sumber Belajar<br />
-Download Contoh RPP K13 Menarik Kelas V Tema Satu Lengkap dengan Langkah-langkah dan Penilaian<br />
-Download Contoh RPP K13 Efektif Kelas V Tema Satu Lengkap dengan Alokasi Waktu dan Bahan Ajar<br />
-Download Contoh RPP K13 Efisien Kelas V Tema Satu Lengkap dengan Lampiran dan Referensi<br />
-Cara Download RPP K13 Gratis Kelas V Tema Satu di Websiteedukasi.com<br />
-Cara Download RPP K13 Gratis Kelas V Tema Satu di Kherysuryawan.id<br />
-Cara Download RPP K13 Gratis Kelas V Tema Satu di Gudangrpp.com<br />
-Cara Membuat RPP K13 Sendiri Kelas V Tema Satu Menggunakan Microsoft Word<br />
-Cara Membuat RPP K13 Sendiri Kelas V Tema Satu Menggunakan Google Docs<br />
-Cara Membuat RPP K13 Sendiri Kelas V Tema Satu Menggunakan Canva.com<br />
-Cara Mengedit RPP K13 Sesuai Keadaan Sekolah Kelas V Tema Satu Menggunakan Microsoft Word<br />
-Cara Mengedit RPP K13 Sesuai Keadaan Sekolah Kelas V Tema Satu Menggunakan Google Docs<br />
-Cara Mengedit RPP K13 Sesuai Keadaan Sekolah Kelas V Tema Satu Menggunakan Canva.com<br />
-Tips Menyusun RPP K13 yang Baik dan Benar Kelas V Tema Satu Sesuai Standar Isi dan Kompetensi Dasar<br />
-Tips Menyusun RPP K13 yang Baik dan Benar Kelas V Tema Satu Sesuai Standar Proses dan Kompetensi Inti<br />
-Tips Menyusun RPP K13 yang Baik dan Benar Kelas V Tema Satu Sesuai Standar Penilaian dan Kompetensi Sikap<br />
-Tips Menyusun RPP K13 yang Baik dan Benar Kelas V Tema Satu</p>
- <ul>
-<li>It requires teachers to have a good understanding of the curriculum, the syllabus, and the learning standards for each subject and grade level.</li>
-<li>It demands teachers to have a clear and measurable learning objectives that align with the competencies and indicators expected from the students.</li>
-<li>It necessitates teachers to have a variety of learning activities that can engage and motivate students to learn actively and meaningfully.</li>
-<li>It obliges teachers to have a valid and reliable assessment that can measure the students' learning outcomes and provide feedback for improvement.</li>
-</ul>
- <h3>The tips for using RPP 1 Lembar</h3>
- <p>Some of the tips that can help teachers to use RPP 1 Lembar effectively are:</p>
- <ul>
-<li>Use a template or a format that is provided by the ministry or the school to write the RPP 1 Lembar quickly and easily.</li>
-<li>Refer to the examples or the models of RPP 1 Lembar that are available online or offline to get some inspiration and guidance.</li>
-<li>Consult with other teachers or experts to get some feedback and suggestions on how to improve the RPP 1 Lembar.</li>
-<li>Review and revise the RPP 1 Lembar regularly to ensure that it is relevant and updated with the latest information and trends.</li>
-</ul>
- <h2>How to download RPP 1 Lembar Kelas 5 Tema 1?</h2>
- <p>If you want to download RPP 1 Lembar Kelas 5 Tema 1, which is the lesson plan for the first theme of grade 5 in elementary school, you can follow these steps:</p>
- <h3>The sources of RPP 1 Lembar Kelas 5 Tema 1</h3>
- <p>There are many sources that offer RPP 1 Lembar Kelas 5 Tema 1 for free or for a fee. Some of them are:</p>
- <ul>
-<li>The official website of the Ministry of Education, Culture, Research and Technology, which provides RPP 1 Lembar for all subjects and grade levels based on the K13 curriculum. You can access it at <a href="">https://kemdikbud.go.id/</a>.</li>
-<li>The online platforms or the blogs that are created by teachers or educators who share their RPP 1 Lembar for various subjects and grade levels. Some examples are <a href="">https://www.gurupendidikan.co.id/</a>, <a href="">https://www.sekolahdasar.net/</a>, and <a href="">https://www.rppkurikulum2013.org/</a>.</li>
-<li>The online marketplaces or the stores that sell RPP 1 Lembar for various subjects and grade levels. Some examples are <a href="">https://www.tokopedia.com/</a>, <a href="">https://www.bukalapak.com/</a>, and <a href="">https://www.shopee.co.id/</a>.</li>
-</ul>
- <h3>The steps to download RPP 1 Lembar Kelas 5 Tema 1</h3>
- <p>The steps to download RPP 1 Lembar Kelas 5 Tema 1 may vary depending on the source that you choose, but generally they are:</p>
- <ol>
-<li>Go to the website or the platform that offers RPP 1 Lembar Kelas 5 Tema 1.</li>
-<li>Search for the keyword "RPP 1 Lembar Kelas 5 Tema 1" or browse through the categories or the tags.</li>
-<li>Select the RPP 1 Lembar Kelas 5 Tema 1 that matches your needs and preferences.</li>
-<li>Click on the download button or the link to download the file. You may need to register, login, or pay a fee before downloading.</li>
-<li>Save the file on your device or print it out if you want.</li>
-</ol>
- <h3>The examples of RPP 1 Lembar Kelas 5 Tema 1</h3>
- <p>Here are some examples of RPP 1 Lemmar Kelas 5 Tema 1 that you can download from different sources:</p>
- <table>
-<tr>
-<th>Source</th>
-<th>Title</th>
-<th>Link</th>
-</tr>
-<tr>
-<td>The Ministry of Education, Culture, Research and Technology</td>
-<td>RPP Satu Halaman SD/MI Kelas V Semester I Tematik Subtema: Organ Gerak Hewan dan Manusia Pembelajaran: I s.d. VI</td>
-<td><a href="">https://kemdikbud.go.id/main/files/download/9f0f0c6d9b0c8c7</a></td>
-</tr>
-<tr>
-<td>Guru Pendidikan</td>
-<td>RPP Satu Halaman Kelas V SD/MI Semester I Tematik Subtema: Organ Gerak Hewan dan Manusia Pembelajaran: I s.d. VI Revisi Terbaru Tahun Pelajaran:2020/2021</td>
-<td><a href="">https://www.gurupendidikan.co.id/rpp-tematik-kelas-5-tema-organ-gerak-hewan-dan-manusia-revisi-terbaru-tahun-pelajaran-2020-2021/</a></td>
-</tr>
-<tr>
-<td>Sekolah Das ar</td>
-<td>RPP 1 Lembar Kelas 5 Tema 1 Subtema 1 Pembelajaran 1-6 Revisi 2020/2021</td>
-<td><a href="">https://www.sekolahdasar.net/2020/07/rpp-1-lembar-kelas-5-tema-1-subtema-1.html</a></td>
-</tr>
-<tr>
-<td>Tokopedia</td>
-<td>RPP 1 Lembar Kelas 5 Tema 1 Subtema 1-4 Revisi 2020/2021 Lengkap</td>
-<td><a href="">https://www.tokopedia.com/edukasikita/rpp-1-lembar-kelas-5-tema-1-subtema-1-4-revisi-2020-2021-lengkap</a></td>
-</tr>
-</table>
- <h2>How to use RPP 1 Lembar Kelas 5 Tema 1?</h2>
- <p>After you download RPP 1 Lembar Kelas 5 Tema 1, you need to know how to use it in your teaching and learning process. Here are some tips on how to use RPP 1 Lembar Kelas 5 Tema 1:</p>
- <h3>The components of RPP 1 Lembar Kelas 5 Tema 1</h3>
- <p>RPP 1 Lembar Kelas 5 Tema 1 has three main components: learning objectives, learning activities, and assessment. You need to understand each component and how they relate to each other.</p>
- <ul>
-<li>Learning objectives are the statements that describe what the students are expected to know, understand, and do by the end of the lesson. They are derived from the competencies and indicators of the curriculum and the syllabus. They should be specific, measurable, achievable, relevant, and time-bound (SMART).</li>
-<li>Learning activities are the tasks or the exercises that the students perform to achieve the learning objectives. They are designed based on the principles of active learning, student-centered learning, and contextual learning. They should be varied, interactive, meaningful, and challenging.</li>
-<li>Assessment is the process of gathering and analyzing evidence of the students' learning outcomes. It can be formative or summative, depending on the purpose and the timing of the assessment. It should be aligned with the learning objectives and the learning activities. It should be valid, reliable, fair, and useful.</li>
-</ul>
- <h3>The activities of RPP 1 Lembar Kelas 5 Tema 1</h3>
- <p>RPP 1 Lembar Kelas 5 Tema 1 covers the first theme of grade 5 in elementary school, which is "Organ Gerak Hewan dan Manusia" (The Locomotor System of Animals and Humans). It consists of four sub-themes: "Organ Gerak pada Hewan" (The Locomotor System of Animals), "Organ Gerak pada Manusia" (The Locomotor System of Humans), "Perawatan Organ Gerak pada Hewan dan Manusia" (The Care of The Locomotor System of Animals and Humans), and "Peran Organ Gerak pada Hewan dan Manusia" (The Role of The Locomotor System of Animals and Humans).</p>
- <p>Each sub-theme has six learning activities that cover different subjects, such as Indonesian language, mathematics, natural science, social science, art and culture, and physical education. The learning activities are integrated and thematic, meaning that they are related to each other and to the main theme. The learning activities are also inquiry-based, meaning that they involve asking questions, exploring answers, and communicating findings.</p>
- <p>Some examples of the learning activities of RPP 1 Lembar Kelas 5 Tema 1 are:</p>
- <ul>
-<li>Observing and comparing the locomotor system of different animals, such as fish, birds, reptiles, mammals, and insects.</li>
-<li>Identifying and labeling the parts of the human locomotor system, such as bones, muscles, joints, tendons, and ligaments.</li>
-<li>Calculating and measuring the angles of movement of different joints in the human body.</li>
-<li>Explaining and demonstrating how to prevent and treat injuries or diseases related to the locomotor system.</li>
-<li>Creating and presenting a poster or a brochure about the importance of maintaining a healthy locomotor system.</li>
-<li>Performing and appreciating various forms of art and culture that involve movement, such as dance, drama, martial arts, and sports.</li>
-</ul>
- <h3>The assessment of RPP 1 Lembar Kelas 5 Tema 1</h3>
- <p>RPP 1 Lembar Kelas 5 Tema 1 has two types of assessment: formative and summative. Formative assessment is done during the learning process to monitor and improve the students' progress and performance. Summative assessment is done at the end of the learning process to evaluate and measure the students' achievement and mastery.</p>
- <p>Formative assessment can be done through various methods, such as observation, quiz, self-assessment, peer-assessment, portfolio, journal, project, presentation, and feedback. Summative assessment can be done through written test, oral test, performance test, or product test.</p>
- <p>Some examples of the assessment of RPP 1 Lembar Kelas 5 Tema 1 are:</p>
- <ul>
-<li>Observing and scoring the students' participation and cooperation in group work or class discussion.</li>
-<li>Giving a quiz or a test on the concepts and facts related to the locomotor system of animals and humans.</li>
-<li>Asking the students to assess themselves or their peers on their skills and attitudes in performing or appreciating art and culture that involve movement.</li>
-<li>Collecting and evaluating the students' portfolio or journal that contain their reflections and products of their learning activities.</li>
-<li>Asking the students to present their poster or brochure about the importance of maintaining a healthy locomotor system and giving feedback on their content and delivery.</li>
-<li>Giving a performance test or a product test on the students' ability to demonstrate or create a form of art and culture that involve movement.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>RPP 1 Lembar Kelas 5 Tema 1 is a simplified format of lesson plan that covers the first theme of grade 5 in elementary school, which is "Organ Gerak Hewan dan Manusia". It has many benefits for teachers and students, but it also poses some challenges. Therefore, teachers need to know how to download and use it effectively. In this article, we have explained what RPP 1 Lembar is, why it is beneficial, what challenges it poses, and how to download and use it effectively. We hope that this article can help you to improve your teaching and learning process with RPP 1 Lembar Kelas 5 Tema 1.</p>
- <h2>FAQs</h2>
- <p>Here are some frequently asked questions about RPP 1 Lembar Kelas 5 Tema 1:</p>
- <ol>
-<li>What is the difference between RPP 1 Lembar and RPP Lengkap?</li>
-<p>RPP 1 Lembar is a simplified format of RPP that only consists of one page and three components: learning objectives, learning activities, and assessment. RPP Lengkap is a detailed format of RPP that consists of several pages and many components, such as identity, basic competence, indicators, learning materials, methods, media, resources, time allocation, evaluation, remedial, enrichment, etc.</p>
-<li>What is the purpose of using RPP 1 Lembar?</li>
-<p>The purpose of using RPP 1 Lembar is to reduce the administrative burden of teachers and give them more freedom and creativity in teaching. It also aims to focus more on the quality and effectiveness of the learning process, rather than on the formality and bureaucracy.</p>
-<li>How can I make my own RPP 1 Lembar?</li>
-<p>You can make your own RPP 1 Lembar by following these steps:</p>
-<ul>
-<li>Choose a theme or a topic that you want to teach based on the curriculum and the syllabus.</li>
-<li>Determine the learning objectives that you want your students to achieve by the end of the lesson.</li>
-<li>Design the learning activities that can help your students to achieve the learning objectives. You can use various methods, media, resources, and strategies that suit your students' needs and interests.</li>
-<li>Prepare the assessment that can measure your students' learning outcomes. You can use formative or summative assessment methods that align with your learning objectives and activities.</li>
-<li>Write down your RPP 1 Lembar using a template or a format that is provided by the ministry or the school. You can also refer to some examples or models that are available online or offline.</li>
-</ul>
-<li>How can I improve my RPP 1 Lembar?</li>
-<p>You can improve your RPP 1 Lembar by following these tips:</p>
-<ul>
-<li>Review and revise your RPP 1 Lembar regularly to ensure that it is relevant and updated with the latest information and trends.</li>
-<li>Consult with other teachers or experts to get some feedback and suggestions on how to improve your RPP 1 Lembar.</li>
-<li>Try out your RPP 1 Lembar in your classroom and observe how it works. You can also ask your students for their opinions and impressions on your RPP 1 Lembar.</li>
-</ul>
-<li>Where can I find more resources or information about RPP 1 Lembar?</li>
-<p>You can find more resources or information about RPP 1 Lembar from these sources:</p>
-<ul>
-<li>The official website of the Ministry of Education, Culture, Research and Technology, which provides various guidelines, regulations, and materials related to RPP 1 Lembar. You can access it at <a href="">https://kemdikbud.go.id/</a>.</li>
-<li>The online communities or forums that are dedicated to teachers or educators who share their experiences, insights, and tips on using RPP 1 Lembar. Some examples are <a href="">https://www.kompasiana.com/tag/rpp-1-lembar</a>, <a href="">https://www.kaskus.co.id/tag/rpp-1-lembar/</a>, and <a href="">https://www.facebook.com/groups/rpp1lembar/</a>.</li>
-<li>The books or the journals that are written by experts or researchers who discuss the theory, practice, and evaluation of RPP 1 Lembar. Some examples are <a href="">https://www.researchgate.net/publication/344784692_RPP_1_Lembar_Kurikulum_2013_Revisi_2018</a>, <a href="">https://www.researchgate.net/publication/344784692_RPP_1_Lembar_Kurikulum_2013_Revisi_2018</a>, and <a href="">https://scholar.google.com/scholar?hl=en&as_sdt=0%2C5&q=rpp+1+lembar&btnG=</a>.</li>
-</ul></p> 401be4b1e0<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Soccer Platform Find Out the Latest Soccer Standings Statistics and Rankings.md b/spaces/congsaPfin/Manga-OCR/logs/Soccer Platform Find Out the Latest Soccer Standings Statistics and Rankings.md
deleted file mode 100644
index 06f3cc25ec14b7b22072e9fca2de3548d644601f..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Soccer Platform Find Out the Latest Soccer Standings Statistics and Rankings.md	
+++ /dev/null
@@ -1,113 +0,0 @@
-
-<h1>Soccerplatform: A Comprehensive Guide for Soccer Fans and Bettors</h1>
- <p>If you are a soccer fan or a bettor, you probably know how important it is to have access to reliable and up-to-date information about your favorite sport. Whether you want to check the latest results, analyze the statistics, or get some tips and predictions, you need a website that can provide you with everything you need. That's where Soccerplatform comes in.</p>
- <h2>What is Soccerplatform?</h2>
- <p>Soccerplatform is a website that offers a variety of soccer content and features for soccer fans and bettors worldwide. Here are some of the things that you can find on Soccerplatform:</p>
-<h2>soccerplatform</h2><br /><p><b><b>Download</b> &bull;&bull;&bull; <a href="https://urlca.com/2uOahr">https://urlca.com/2uOahr</a></b></p><br /><br />
- <h3>A website that provides soccer statistics, predictions, and tips</h3>
- <p>One of the main attractions of Soccerplatform is its extensive database of soccer statistics, results, and analysis. You can find data on more than 1500 soccer leagues and competitions worldwide, including the most popular ones like the Premier League, La Liga, Serie A, Bundesliga, Champions League, Europa League, World Cup, Euro Qualifiers, etc. You can also compare teams, players, and matches using various criteria and indicators.</p>
- <p>But that's not all. Soccerplatform also offers free soccer predictions and tips for every match. You can follow the expert opinions of the website's tipsters or use your own research and knowledge to make your own predictions. You can also see the odds, trends, form tables, live scores, and more.</p>
-<p>soccerplatform free soccer predictions<br />
-soccerplatform football tips and picks<br />
-soccerplatform best betting odds<br />
-soccerplatform live scores and results<br />
-soccerplatform match previews and analysis<br />
-soccerplatform soccer news and updates<br />
-soccerplatform VIP membership and benefits<br />
-soccerplatform daily football predictions<br />
-soccerplatform accurate soccer tips<br />
-soccerplatform top leagues and competitions<br />
-soccerplatform goal scorers and statistics<br />
-soccerplatform head to head records<br />
-soccerplatform team news and injuries<br />
-soccerplatform expert advice and guides<br />
-soccerplatform customer support and feedback<br />
-soccerplatform mobile app and website<br />
-soccerplatform latest offers and promotions<br />
-soccerplatform match reports and highlights<br />
-soccerplatform user reviews and testimonials<br />
-soccerplatform subscription plans and prices<br />
-soccerplatform money back guarantee and refund policy<br />
-soccerplatform affiliate program and commission rates<br />
-soccerplatform social media and community<br />
-soccerplatform FAQ and help center<br />
-soccerplatform contact us and location<br />
-soccerplatform terms and conditions and privacy policy<br />
-soccerplatform blog and newsletter<br />
-soccerplatform careers and opportunities<br />
-soccerplatform awards and recognition<br />
-soccerplatform partners and sponsors<br />
-soccerplatform features and services<br />
-soccerplatform how it works and why choose us<br />
-soccerplatform success stories and case studies<br />
-soccerplatform ratings and rankings<br />
-soccerplatform coupons and discounts<br />
-soccerplatform payment methods and security<br />
-soccerplatform login and registration<br />
-soccerplatform video tutorials and webinars<br />
-soccerplatform trial period and free access<br />
-soccerplatform compare with other platforms<br />
-soccerplatform performance and reliability<br />
-soccerplatform customer loyalty program and rewards<br />
-soccerplatform refer a friend and earn bonus<br />
-soccerplatform join now and get started<br />
-soccerplatform feedback form and survey<br />
-soccerplatform support chat and phone number<br />
-soccerplatform download app and install instructions<br />
-soccerplatform upcoming matches and events</p>
- <h3>A platform that connects soccer fans and bettors worldwide</h3>
- <p>Soccerplatform is not just a website. It's also a community of soccer enthusiasts who share their passion for the beautiful game. You can join Soccerplatform for free and interact with other users in the forums, chat rooms, blogs, etc. You can also participate in contests, polls, quizzes, games, etc. You can also follow Soccerplatform on social media platforms like Facebook, Twitter, Instagram, etc.</p>
- <h3>A source of information and entertainment for soccer lovers</h3>
- <p>Soccerplatform is not only about statistics and betting. It's also about having fun and enjoying soccer in all its aspects. You can find a lot of interesting and entertaining content on Soccerplatform, such as articles, news, videos, podcasts, etc. You can also learn more about soccer history, culture, trivia, etc.</p>
- <h2>Why use Soccerplatform?</h2>
- <p>There are many reasons why you should use Soccerplatform if you are a soccer fan or a bettor. Here are some of them:</p>
- <h3>To access reliable and up-to-date soccer data and analysis</h3>
- <p>If you want to be well-informed about soccer, you need a website that can provide you with accurate and comprehensive data and analysis. Soccerplatform is one of the best websites in this regard. It uses advanced algorithms and methods to collect, process, and present soccer data in an easy-to-understand way. It also updates its data regularly to reflect the latest developments in the soccer world.</p>
- <h3>To improve your soccer betting skills and strategies</h3>
- <p>If you want to be successful in soccer betting, you need a website that can help you improve your skills and strategies. Soccerplatform is one of the best websites in this regard. It offers free soccer predictions and tips for every match, based on statistical analysis, expert opinions, and user feedback. It also gives you access to the best soccer betting sites, offers, and bonuses. You can also track your betting performance and history on Soccerplatform.</p>
- <h3>To enjoy a variety of soccer content and features</h3>
- <p>If you want to have fun and enjoy soccer in all its aspects, you need a website that can offer you a variety of soccer content and features. Soccerplatform is one of the best websites in this regard. It has something for everyone, whether you are interested in soccer news, videos, podcasts, articles, games, quizzes, etc. You can also customize your Soccerplatform experience by choosing your favorite soccer competitions, teams, and players.</p>
- <h2>How to use Soccerplatform?</h2>
- <p>Using Soccerplatform is very easy and convenient. Here are the steps that you need to follow:</p>
- <h3>Register for free and log in to the website</h3>
- <p>The first thing that you need to do is to register for free on Soccerplatform. You can do this by clicking on the "Register" button on the top right corner of the website. You will need to provide some basic information, such as your name, email address, password, etc. You can also sign up using your Facebook or Google account.</p>
- <p>Once you have registered, you can log in to the website using your email address and password or your social media account. You will then be able to access all the features and content of Soccerplatform.</p>
- <h3>Choose your preferred soccer competitions and teams</h3>
- <p>The next thing that you need to do is to choose your preferred soccer competitions and teams. You can do this by clicking on the "Competitions" or "Teams" tabs on the top menu of the website. You will see a list of all the soccer leagues and competitions that are available on Soccerplatform. You can also use the search bar to find a specific competition or team.</p>
- <p>Once you have found your preferred soccer competition or team, you can click on it to see more details, such as the standings, fixtures, results, statistics, predictions, tips, etc. You can also add it to your favorites by clicking on the star icon next to it. This way, you can easily access it from your dashboard or profile.</p>
- <h3>Browse through the different sections and categories</h3>
- <p>The next thing that you need to do is to browse through the different sections and categories of Soccerplatform. You can do this by clicking on the tabs on the top menu of the website. You will see different options, such as "Home", "Predictions", "Tips", "Statistics", "Results", "Live Scores", "News", "Videos", "Podcasts", "Articles", "Games", "Quizzes", etc.</p>
- <p>Each section and category has its own subcategories and filters that you can use to narrow down your search or preference. For example, if you click on the "Predictions" tab, you will see subcategories such as "Today", "Tomorrow", "Weekend", etc. You can also filter by competition, team, date, time, odds, etc.</p>
- <p>You can click on any section or category that interests you and explore its content and features. You can also comment, like, share, or rate any content that you find on Soccerplatform.</p>
- <h3>Follow the expert tips and predictions or create your own</h3>
- <p>The next thing that you need to do is to follow the expert tips and predictions or create your own. You can do this by clicking on the "Tips" or "Predictions" tabs on the top menu of the website. You will see a list of all the tips and predictions that are available on Soccerplatform. You can also use the filters and subcategories to find the ones that suit your needs.</p>
- <p>You can click on any tip or prediction that interests you and see more details, such as the analysis, reasoning, odds, stake, etc. You can also follow the tipster or predictor who created it by clicking on their name or profile picture. This way, you can see their performance history and other tips and predictions that they have made.</p>
- <p>If you want to create your own tip or prediction, you can do so by clicking on the "Create Tip" or "Create Prediction" button on the top right corner of the website. You will need to provide some information, such as the match, outcome, odds, stake, analysis, etc. You can also upload a photo or a video to support your tip or prediction. You can then submit your tip or prediction and share it with other users on Soccerplatform.</p>
- <h2>What are the benefits of Soccerplatform?</h2>
- <p>Using Soccerplatform has many benefits for soccer fans and bettors. Here are some of them:</p>
- <h3>You can get accurate and comprehensive soccer statistics and results</h3>
- <p>Soccerplatform has one of the most extensive and reliable soccer databases in the world. You can get access to soccer statistics and results from more than 1500 soccer leagues and competitions worldwide. You can also compare teams, players, and matches using various criteria and indicators. You can use this information to enhance your soccer knowledge and understanding.</p>
- <h3>You can learn from the best soccer tipsters and analysts</h3>
- <p>Soccerplatform has a team of professional and experienced soccer tipsters and analysts who provide free soccer predictions and tips for every match. You can follow their advice and opinions or use them as a reference for your own predictions and tips. You can also see their performance history and ratings to evaluate their credibility and quality.</p>
- <h3>You can interact with other soccer fans and bettors in the community</h3>
- <p>Soccerplatform has a large and active community of soccer enthusiasts who share their passion for the beautiful game. You can join Soccerplatform for free and interact with other users in the forums, chat rooms, blogs, etc. You can also participate in contests, polls, quizzes, games, etc. You can also follow Soccerplatform on social media platforms like Facebook, Twitter, Instagram, etc.</p>
- <h3>You can have fun and win money with soccer betting</h3>
- <p>Soccerplatform is not only a website for soccer information and entertainment. It's also a website for soccer betting. You can use Soccerplatform to improve your soccer betting skills and strategies by following the expert tips and predictions or creating your own. You can also access the best soccer betting sites, offers, and bonuses on Soccerplatform. You can also track your betting performance and history on Soccerplatform.</p>
- <h2>Conclusion</h2>
- <p>Soccerplatform is a website that offers a variety of soccer content and features for soccer fans and bettors worldwide. It is a website that provides soccer statistics, predictions, and tips; a platform that connects soccer fans and bettors worldwide; and a source of information and entertainment for soccer lovers. It is a website that you should use if you want to access reliable and up-to-date soccer data and analysis; improve your soccer betting skills and strategies; enjoy a variety of soccer content and features; and have fun and win money with soccer betting.</p>
- <p>If you are interested in Soccerplatform, you can visit their website at www.soccerplatform.com or follow them on social media platforms like Facebook, Twitter, Instagram, etc. You can also register for free on Soccerplatform and start using their features and content right away.</p>
- <p>Thank you for reading this article. We hope that you found it useful and informative. If you have any questions or feedback, please feel free to leave them in the comments section below.</p>
- <h2>FAQs</h2>
- <p>Here are some of the frequently asked questions about Soccerplatform:</p>
- <h4>Q: Is Soccerplatform free to use?</h4>
-<p>A: Yes, Soccerplatform is free to use for all users. You can access all the features and content of Soccerplatform without paying anything. However, if you want to access some premium features or content, such as VIP tips or predictions, you may need to pay a small fee.</p>
- <h4>Q: How reliable are the tips and predictions on Soccerplatform?</h4>
-<p>A: The tips and predictions on Soccerplatform are based on statistical analysis, expert opinions, user feedback, etc. They are not 100% guaranteed to be accurate or successful, but they are generally reliable and helpful for soccer fans and bettors. You can also check the ratings and reviews of the tipsters and predictors who created them to see their credibility and quality.</p>
- <h4>Q: How can I create my own tip or prediction on Soccerplatform?</h4>
-<p>A: You can create your own tip or prediction on Soccerplatform by clicking on the "Create Tip" or "Create Prediction" button on the top right corner of the website. You will need to provide some information, such as the match, outcome, odds, stake, analysis, etc. You can also upload a photo or a video to support your tip or prediction. You can then submit your tip or prediction and share it with other users on Soccerplatform.</p>
- <h4>Q: How can I join the community on Soccerplatform?</h4>
-<p>A: You can join the community on Soccerplatform by registering for free on the website and logging in to your account. You can then interact with other users in the forums, chat rooms, blogs, etc. You can also participate in contests, polls, quizzes, games, etc. You can also follow Soccerplatform on social media platforms like Facebook, Twitter, Instagram, etc.</p>
- <h4>Q: How can I contact Soccerplatform?</h4>
-<p>A: You can contact Soccerplatform by using the contact form on their website or by sending an email to info@soccerplatform.com. You can also reach them through their social media platforms like Facebook, Twitter, Instagram, etc.</p> 401be4b1e0<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/contluForse/HuggingGPT/assets/Beyond Compare 4 Serial Key.md b/spaces/contluForse/HuggingGPT/assets/Beyond Compare 4 Serial Key.md
deleted file mode 100644
index 0ce57e7e6f471a050f52489ea38945b364d6e357..0000000000000000000000000000000000000000
--- a/spaces/contluForse/HuggingGPT/assets/Beyond Compare 4 Serial Key.md	
+++ /dev/null
@@ -1,5 +0,0 @@
-<br />
-<p>Convincing evidence was also presented that the defendant knew the marihuana was in the Chrysler. See Commonwealth v. LaPerle, 19 Mass. App. Ct. 424, 426-427 (1985), quoting from Commonwealth v. Altenhaus, 317 Mass. 270, 273 (1944) ("Knowledge `may be, and generally is, proved by circumstantial evidence; and it may be inferred from a great variety of circumstances'"). Evidence was presented of the defendant's illicit drug activity, including the discovery of drug paraphernalia in his apartment and the discovery of eight hundred dollars in cash on the front seat of the Chrysler. See Commonwealth v. Brzezinski, 405 Mass. 401, 410 (1989) (possession of large amounts of cash evidence of drug dealing); Mercedes v. Commonwealth, 405 Mass. 693, 693-694 (1989) (possession of drug paraphernalia and large amounts of cash evidence of drug dealing). His attempt to put the key to the Chrysler automobile in his mouth while he was being booked on a drug charge, taken in the context of the other evidence of his drug dealing, provided a sufficient basis for inferring that he was attempting to secrete the key because he knew the marihuana was in the trunk of the automobile. Viewing the evidence in the light most favorable to the Commonwealth, see Commonwealth v. Latimore, 378 Mass. 671, 676-678 (1979); Commonwealth v. Merola, 405 Mass. 529, 533 (1989), a fact finder could conclude beyond a reasonable doubt that the defendant had been in possession of the marihuana seized from the trunk of the Chrysler automobile.</p>
-<h2>Beyond Compare 4 Serial Key</h2><br /><p><b><b>Download</b> &#8250; <a href="https://ssurll.com/2uzvkH">https://ssurll.com/2uzvkH</a></b></p><br /><br /> aaccfb2cb3<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/contluForse/HuggingGPT/assets/Crystal Reports 10 Advanced Developer Build 10.0.0.53327 Key.rar _VERIFIED_.md b/spaces/contluForse/HuggingGPT/assets/Crystal Reports 10 Advanced Developer Build 10.0.0.53327 Key.rar _VERIFIED_.md
deleted file mode 100644
index 9000af4c32f499c74a6c18d5c025d7ffca50b7b3..0000000000000000000000000000000000000000
--- a/spaces/contluForse/HuggingGPT/assets/Crystal Reports 10 Advanced Developer Build 10.0.0.53327 Key.rar _VERIFIED_.md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>Crystal Reports 10 Advanced Developer Build 10.0.0.53327 Key.rar</h2><br /><p><b><b>Download</b> &middot;&middot;&middot;&middot;&middot; <a href="https://ssurll.com/2uzw6l">https://ssurll.com/2uzw6l</a></b></p><br /><br />
-
-Smart-Serials - Serials for Crystal Report 9 unlock with serial key. . 5979. crystal reports 10 Advanced Developer Build 10.0.0.53327 key.rar,. 4d29de3e1b<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/layers/csrc/nms_rotated/nms_rotated.h b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/layers/csrc/nms_rotated/nms_rotated.h
deleted file mode 100644
index 12aca388e47b12dafd20999f2991a9d42f4b904b..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/layers/csrc/nms_rotated/nms_rotated.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates.
-#pragma once
-#include <torch/types.h>
-
-namespace detectron2 {
-
-at::Tensor nms_rotated_cpu(
-    const at::Tensor& dets,
-    const at::Tensor& scores,
-    const double iou_threshold);
-
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-at::Tensor nms_rotated_cuda(
-    const at::Tensor& dets,
-    const at::Tensor& scores,
-    const double iou_threshold);
-#endif
-
-// Interface for Python
-// inline is needed to prevent multiple function definitions when this header is
-// included by different cpps
-inline at::Tensor nms_rotated(
-    const at::Tensor& dets,
-    const at::Tensor& scores,
-    const double iou_threshold) {
-  assert(dets.device().is_cuda() == scores.device().is_cuda());
-  if (dets.device().is_cuda()) {
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-    return nms_rotated_cuda(
-        dets.contiguous(), scores.contiguous(), iou_threshold);
-#else
-    AT_ERROR("Detectron2 is not compiled with GPU support!");
-#endif
-  }
-
-  return nms_rotated_cpu(dets.contiguous(), scores.contiguous(), iou_threshold);
-}
-
-} // namespace detectron2
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/utils/registry.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/utils/registry.py
deleted file mode 100644
index 4b01e9007c2578a7b5ae555c926cc06c8a3010f9..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/utils/registry.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-from typing import Any
-import pydoc
-from fvcore.common.registry import Registry  # for backward compatibility.
-
-"""
-``Registry`` and `locate` provide ways to map a string (typically found
-in config files) to callable objects.
-"""
-
-__all__ = ["Registry", "locate"]
-
-
-def _convert_target_to_string(t: Any) -> str:
-    """
-    Inverse of ``locate()``.
-
-    Args:
-        t: any object with ``__module__`` and ``__qualname__``
-    """
-    module, qualname = t.__module__, t.__qualname__
-
-    # Compress the path to this object, e.g. ``module.submodule._impl.class``
-    # may become ``module.submodule.class``, if the later also resolves to the same
-    # object. This simplifies the string, and also is less affected by moving the
-    # class implementation.
-    module_parts = module.split(".")
-    for k in range(1, len(module_parts)):
-        prefix = ".".join(module_parts[:k])
-        candidate = f"{prefix}.{qualname}"
-        try:
-            if locate(candidate) is t:
-                return candidate
-        except ImportError:
-            pass
-    return f"{module}.{qualname}"
-
-
-def locate(name: str) -> Any:
-    """
-    Locate and return an object ``x`` using an input string ``{x.__module__}.{x.__qualname__}``,
-    such as "module.submodule.class_name".
-
-    Raise Exception if it cannot be found.
-    """
-    obj = pydoc.locate(name)
-
-    # Some cases (e.g. torch.optim.sgd.SGD) not handled correctly
-    # by pydoc.locate. Try a private function from hydra.
-    if obj is None:
-        try:
-            # from hydra.utils import get_method - will print many errors
-            from hydra.utils import _locate
-        except ImportError as e:
-            raise ImportError(f"Cannot dynamically locate object {name}!") from e
-        else:
-            obj = _locate(name)  # it raises if fails
-
-    return obj
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/mmcv/runner/hooks/optimizer.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/mmcv/runner/hooks/optimizer.py
deleted file mode 100644
index 4ef3e9ff8f9c6926e32bdf027612267b64ed80df..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/mmcv/runner/hooks/optimizer.py
+++ /dev/null
@@ -1,508 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import copy
-from collections import defaultdict
-from itertools import chain
-
-from torch.nn.utils import clip_grad
-
-from annotator.uniformer.mmcv.utils import TORCH_VERSION, _BatchNorm, digit_version
-from ..dist_utils import allreduce_grads
-from ..fp16_utils import LossScaler, wrap_fp16_model
-from .hook import HOOKS, Hook
-
-try:
-    # If PyTorch version >= 1.6.0, torch.cuda.amp.GradScaler would be imported
-    # and used; otherwise, auto fp16 will adopt mmcv's implementation.
-    from torch.cuda.amp import GradScaler
-except ImportError:
-    pass
-
-
-@HOOKS.register_module()
-class OptimizerHook(Hook):
-
-    def __init__(self, grad_clip=None):
-        self.grad_clip = grad_clip
-
-    def clip_grads(self, params):
-        params = list(
-            filter(lambda p: p.requires_grad and p.grad is not None, params))
-        if len(params) > 0:
-            return clip_grad.clip_grad_norm_(params, **self.grad_clip)
-
-    def after_train_iter(self, runner):
-        runner.optimizer.zero_grad()
-        runner.outputs['loss'].backward()
-        if self.grad_clip is not None:
-            grad_norm = self.clip_grads(runner.model.parameters())
-            if grad_norm is not None:
-                # Add grad norm to the logger
-                runner.log_buffer.update({'grad_norm': float(grad_norm)},
-                                         runner.outputs['num_samples'])
-        runner.optimizer.step()
-
-
-@HOOKS.register_module()
-class GradientCumulativeOptimizerHook(OptimizerHook):
-    """Optimizer Hook implements multi-iters gradient cumulating.
-
-    Args:
-        cumulative_iters (int, optional): Num of gradient cumulative iters.
-            The optimizer will step every `cumulative_iters` iters.
-            Defaults to 1.
-
-    Examples:
-        >>> # Use cumulative_iters to simulate a large batch size
-        >>> # It is helpful when the hardware cannot handle a large batch size.
-        >>> loader = DataLoader(data, batch_size=64)
-        >>> optim_hook = GradientCumulativeOptimizerHook(cumulative_iters=4)
-        >>> # almost equals to
-        >>> loader = DataLoader(data, batch_size=256)
-        >>> optim_hook = OptimizerHook()
-    """
-
-    def __init__(self, cumulative_iters=1, **kwargs):
-        super(GradientCumulativeOptimizerHook, self).__init__(**kwargs)
-
-        assert isinstance(cumulative_iters, int) and cumulative_iters > 0, \
-            f'cumulative_iters only accepts positive int, but got ' \
-            f'{type(cumulative_iters)} instead.'
-
-        self.cumulative_iters = cumulative_iters
-        self.divisible_iters = 0
-        self.remainder_iters = 0
-        self.initialized = False
-
-    def has_batch_norm(self, module):
-        if isinstance(module, _BatchNorm):
-            return True
-        for m in module.children():
-            if self.has_batch_norm(m):
-                return True
-        return False
-
-    def _init(self, runner):
-        if runner.iter % self.cumulative_iters != 0:
-            runner.logger.warning(
-                'Resume iter number is not divisible by cumulative_iters in '
-                'GradientCumulativeOptimizerHook, which means the gradient of '
-                'some iters is lost and the result may be influenced slightly.'
-            )
-
-        if self.has_batch_norm(runner.model) and self.cumulative_iters > 1:
-            runner.logger.warning(
-                'GradientCumulativeOptimizerHook may slightly decrease '
-                'performance if the model has BatchNorm layers.')
-
-        residual_iters = runner.max_iters - runner.iter
-
-        self.divisible_iters = (
-            residual_iters // self.cumulative_iters * self.cumulative_iters)
-        self.remainder_iters = residual_iters - self.divisible_iters
-
-        self.initialized = True
-
-    def after_train_iter(self, runner):
-        if not self.initialized:
-            self._init(runner)
-
-        if runner.iter < self.divisible_iters:
-            loss_factor = self.cumulative_iters
-        else:
-            loss_factor = self.remainder_iters
-        loss = runner.outputs['loss']
-        loss = loss / loss_factor
-        loss.backward()
-
-        if (self.every_n_iters(runner, self.cumulative_iters)
-                or self.is_last_iter(runner)):
-
-            if self.grad_clip is not None:
-                grad_norm = self.clip_grads(runner.model.parameters())
-                if grad_norm is not None:
-                    # Add grad norm to the logger
-                    runner.log_buffer.update({'grad_norm': float(grad_norm)},
-                                             runner.outputs['num_samples'])
-            runner.optimizer.step()
-            runner.optimizer.zero_grad()
-
-
-if (TORCH_VERSION != 'parrots'
-        and digit_version(TORCH_VERSION) >= digit_version('1.6.0')):
-
-    @HOOKS.register_module()
-    class Fp16OptimizerHook(OptimizerHook):
-        """FP16 optimizer hook (using PyTorch's implementation).
-
-        If you are using PyTorch >= 1.6, torch.cuda.amp is used as the backend,
-        to take care of the optimization procedure.
-
-        Args:
-            loss_scale (float | str | dict): Scale factor configuration.
-                If loss_scale is a float, static loss scaling will be used with
-                the specified scale. If loss_scale is a string, it must be
-                'dynamic', then dynamic loss scaling will be used.
-                It can also be a dict containing arguments of GradScalar.
-                Defaults to 512. For Pytorch >= 1.6, mmcv uses official
-                implementation of GradScaler. If you use a dict version of
-                loss_scale to create GradScaler, please refer to:
-                https://pytorch.org/docs/stable/amp.html#torch.cuda.amp.GradScaler
-                for the parameters.
-
-        Examples:
-            >>> loss_scale = dict(
-            ...     init_scale=65536.0,
-            ...     growth_factor=2.0,
-            ...     backoff_factor=0.5,
-            ...     growth_interval=2000
-            ... )
-            >>> optimizer_hook = Fp16OptimizerHook(loss_scale=loss_scale)
-        """
-
-        def __init__(self,
-                     grad_clip=None,
-                     coalesce=True,
-                     bucket_size_mb=-1,
-                     loss_scale=512.,
-                     distributed=True):
-            self.grad_clip = grad_clip
-            self.coalesce = coalesce
-            self.bucket_size_mb = bucket_size_mb
-            self.distributed = distributed
-            self._scale_update_param = None
-            if loss_scale == 'dynamic':
-                self.loss_scaler = GradScaler()
-            elif isinstance(loss_scale, float):
-                self._scale_update_param = loss_scale
-                self.loss_scaler = GradScaler(init_scale=loss_scale)
-            elif isinstance(loss_scale, dict):
-                self.loss_scaler = GradScaler(**loss_scale)
-            else:
-                raise ValueError('loss_scale must be of type float, dict, or '
-                                 f'"dynamic", got {loss_scale}')
-
-        def before_run(self, runner):
-            """Preparing steps before Mixed Precision Training."""
-            # wrap model mode to fp16
-            wrap_fp16_model(runner.model)
-            # resume from state dict
-            if 'fp16' in runner.meta and 'loss_scaler' in runner.meta['fp16']:
-                scaler_state_dict = runner.meta['fp16']['loss_scaler']
-                self.loss_scaler.load_state_dict(scaler_state_dict)
-
-        def copy_grads_to_fp32(self, fp16_net, fp32_weights):
-            """Copy gradients from fp16 model to fp32 weight copy."""
-            for fp32_param, fp16_param in zip(fp32_weights,
-                                              fp16_net.parameters()):
-                if fp16_param.grad is not None:
-                    if fp32_param.grad is None:
-                        fp32_param.grad = fp32_param.data.new(
-                            fp32_param.size())
-                    fp32_param.grad.copy_(fp16_param.grad)
-
-        def copy_params_to_fp16(self, fp16_net, fp32_weights):
-            """Copy updated params from fp32 weight copy to fp16 model."""
-            for fp16_param, fp32_param in zip(fp16_net.parameters(),
-                                              fp32_weights):
-                fp16_param.data.copy_(fp32_param.data)
-
-        def after_train_iter(self, runner):
-            """Backward optimization steps for Mixed Precision Training. For
-            dynamic loss scaling, please refer to
-            https://pytorch.org/docs/stable/amp.html#torch.cuda.amp.GradScaler.
-
-            1. Scale the loss by a scale factor.
-            2. Backward the loss to obtain the gradients.
-            3. Unscale the optimizer’s gradient tensors.
-            4. Call optimizer.step() and update scale factor.
-            5. Save loss_scaler state_dict for resume purpose.
-            """
-            # clear grads of last iteration
-            runner.model.zero_grad()
-            runner.optimizer.zero_grad()
-
-            self.loss_scaler.scale(runner.outputs['loss']).backward()
-            self.loss_scaler.unscale_(runner.optimizer)
-            # grad clip
-            if self.grad_clip is not None:
-                grad_norm = self.clip_grads(runner.model.parameters())
-                if grad_norm is not None:
-                    # Add grad norm to the logger
-                    runner.log_buffer.update({'grad_norm': float(grad_norm)},
-                                             runner.outputs['num_samples'])
-            # backward and update scaler
-            self.loss_scaler.step(runner.optimizer)
-            self.loss_scaler.update(self._scale_update_param)
-
-            # save state_dict of loss_scaler
-            runner.meta.setdefault(
-                'fp16', {})['loss_scaler'] = self.loss_scaler.state_dict()
-
-    @HOOKS.register_module()
-    class GradientCumulativeFp16OptimizerHook(GradientCumulativeOptimizerHook,
-                                              Fp16OptimizerHook):
-        """Fp16 optimizer Hook (using PyTorch's implementation) implements
-        multi-iters gradient cumulating.
-
-        If you are using PyTorch >= 1.6, torch.cuda.amp is used as the backend,
-        to take care of the optimization procedure.
-        """
-
-        def __init__(self, *args, **kwargs):
-            super(GradientCumulativeFp16OptimizerHook,
-                  self).__init__(*args, **kwargs)
-
-        def after_train_iter(self, runner):
-            if not self.initialized:
-                self._init(runner)
-
-            if runner.iter < self.divisible_iters:
-                loss_factor = self.cumulative_iters
-            else:
-                loss_factor = self.remainder_iters
-            loss = runner.outputs['loss']
-            loss = loss / loss_factor
-
-            self.loss_scaler.scale(loss).backward()
-
-            if (self.every_n_iters(runner, self.cumulative_iters)
-                    or self.is_last_iter(runner)):
-
-                # copy fp16 grads in the model to fp32 params in the optimizer
-                self.loss_scaler.unscale_(runner.optimizer)
-
-                if self.grad_clip is not None:
-                    grad_norm = self.clip_grads(runner.model.parameters())
-                    if grad_norm is not None:
-                        # Add grad norm to the logger
-                        runner.log_buffer.update(
-                            {'grad_norm': float(grad_norm)},
-                            runner.outputs['num_samples'])
-
-                # backward and update scaler
-                self.loss_scaler.step(runner.optimizer)
-                self.loss_scaler.update(self._scale_update_param)
-
-                # save state_dict of loss_scaler
-                runner.meta.setdefault(
-                    'fp16', {})['loss_scaler'] = self.loss_scaler.state_dict()
-
-                # clear grads
-                runner.model.zero_grad()
-                runner.optimizer.zero_grad()
-
-else:
-
-    @HOOKS.register_module()
-    class Fp16OptimizerHook(OptimizerHook):
-        """FP16 optimizer hook (mmcv's implementation).
-
-        The steps of fp16 optimizer is as follows.
-        1. Scale the loss value.
-        2. BP in the fp16 model.
-        2. Copy gradients from fp16 model to fp32 weights.
-        3. Update fp32 weights.
-        4. Copy updated parameters from fp32 weights to fp16 model.
-
-        Refer to https://arxiv.org/abs/1710.03740 for more details.
-
-        Args:
-            loss_scale (float | str | dict): Scale factor configuration.
-                If loss_scale is a float, static loss scaling will be used with
-                the specified scale. If loss_scale is a string, it must be
-                'dynamic', then dynamic loss scaling will be used.
-                It can also be a dict containing arguments of LossScaler.
-                Defaults to 512.
-        """
-
-        def __init__(self,
-                     grad_clip=None,
-                     coalesce=True,
-                     bucket_size_mb=-1,
-                     loss_scale=512.,
-                     distributed=True):
-            self.grad_clip = grad_clip
-            self.coalesce = coalesce
-            self.bucket_size_mb = bucket_size_mb
-            self.distributed = distributed
-            if loss_scale == 'dynamic':
-                self.loss_scaler = LossScaler(mode='dynamic')
-            elif isinstance(loss_scale, float):
-                self.loss_scaler = LossScaler(
-                    init_scale=loss_scale, mode='static')
-            elif isinstance(loss_scale, dict):
-                self.loss_scaler = LossScaler(**loss_scale)
-            else:
-                raise ValueError('loss_scale must be of type float, dict, or '
-                                 f'"dynamic", got {loss_scale}')
-
-        def before_run(self, runner):
-            """Preparing steps before Mixed Precision Training.
-
-            1. Make a master copy of fp32 weights for optimization.
-            2. Convert the main model from fp32 to fp16.
-            """
-            # keep a copy of fp32 weights
-            old_groups = runner.optimizer.param_groups
-            runner.optimizer.param_groups = copy.deepcopy(
-                runner.optimizer.param_groups)
-            state = defaultdict(dict)
-            p_map = {
-                old_p: p
-                for old_p, p in zip(
-                    chain(*(g['params'] for g in old_groups)),
-                    chain(*(g['params']
-                            for g in runner.optimizer.param_groups)))
-            }
-            for k, v in runner.optimizer.state.items():
-                state[p_map[k]] = v
-            runner.optimizer.state = state
-            # convert model to fp16
-            wrap_fp16_model(runner.model)
-            # resume from state dict
-            if 'fp16' in runner.meta and 'loss_scaler' in runner.meta['fp16']:
-                scaler_state_dict = runner.meta['fp16']['loss_scaler']
-                self.loss_scaler.load_state_dict(scaler_state_dict)
-
-        def copy_grads_to_fp32(self, fp16_net, fp32_weights):
-            """Copy gradients from fp16 model to fp32 weight copy."""
-            for fp32_param, fp16_param in zip(fp32_weights,
-                                              fp16_net.parameters()):
-                if fp16_param.grad is not None:
-                    if fp32_param.grad is None:
-                        fp32_param.grad = fp32_param.data.new(
-                            fp32_param.size())
-                    fp32_param.grad.copy_(fp16_param.grad)
-
-        def copy_params_to_fp16(self, fp16_net, fp32_weights):
-            """Copy updated params from fp32 weight copy to fp16 model."""
-            for fp16_param, fp32_param in zip(fp16_net.parameters(),
-                                              fp32_weights):
-                fp16_param.data.copy_(fp32_param.data)
-
-        def after_train_iter(self, runner):
-            """Backward optimization steps for Mixed Precision Training. For
-            dynamic loss scaling, please refer `loss_scalar.py`
-
-            1. Scale the loss by a scale factor.
-            2. Backward the loss to obtain the gradients (fp16).
-            3. Copy gradients from the model to the fp32 weight copy.
-            4. Scale the gradients back and update the fp32 weight copy.
-            5. Copy back the params from fp32 weight copy to the fp16 model.
-            6. Save loss_scaler state_dict for resume purpose.
-            """
-            # clear grads of last iteration
-            runner.model.zero_grad()
-            runner.optimizer.zero_grad()
-            # scale the loss value
-            scaled_loss = runner.outputs['loss'] * self.loss_scaler.loss_scale
-            scaled_loss.backward()
-            # copy fp16 grads in the model to fp32 params in the optimizer
-
-            fp32_weights = []
-            for param_group in runner.optimizer.param_groups:
-                fp32_weights += param_group['params']
-            self.copy_grads_to_fp32(runner.model, fp32_weights)
-            # allreduce grads
-            if self.distributed:
-                allreduce_grads(fp32_weights, self.coalesce,
-                                self.bucket_size_mb)
-
-            has_overflow = self.loss_scaler.has_overflow(fp32_weights)
-            # if has overflow, skip this iteration
-            if not has_overflow:
-                # scale the gradients back
-                for param in fp32_weights:
-                    if param.grad is not None:
-                        param.grad.div_(self.loss_scaler.loss_scale)
-                if self.grad_clip is not None:
-                    grad_norm = self.clip_grads(fp32_weights)
-                    if grad_norm is not None:
-                        # Add grad norm to the logger
-                        runner.log_buffer.update(
-                            {'grad_norm': float(grad_norm)},
-                            runner.outputs['num_samples'])
-                # update fp32 params
-                runner.optimizer.step()
-                # copy fp32 params to the fp16 model
-                self.copy_params_to_fp16(runner.model, fp32_weights)
-            self.loss_scaler.update_scale(has_overflow)
-            if has_overflow:
-                runner.logger.warning('Check overflow, downscale loss scale '
-                                      f'to {self.loss_scaler.cur_scale}')
-
-            # save state_dict of loss_scaler
-            runner.meta.setdefault(
-                'fp16', {})['loss_scaler'] = self.loss_scaler.state_dict()
-
-    @HOOKS.register_module()
-    class GradientCumulativeFp16OptimizerHook(GradientCumulativeOptimizerHook,
-                                              Fp16OptimizerHook):
-        """Fp16 optimizer Hook (using mmcv implementation) implements multi-
-        iters gradient cumulating."""
-
-        def __init__(self, *args, **kwargs):
-            super(GradientCumulativeFp16OptimizerHook,
-                  self).__init__(*args, **kwargs)
-
-        def after_train_iter(self, runner):
-            if not self.initialized:
-                self._init(runner)
-
-            if runner.iter < self.divisible_iters:
-                loss_factor = self.cumulative_iters
-            else:
-                loss_factor = self.remainder_iters
-
-            loss = runner.outputs['loss']
-            loss = loss / loss_factor
-
-            # scale the loss value
-            scaled_loss = loss * self.loss_scaler.loss_scale
-            scaled_loss.backward()
-
-            if (self.every_n_iters(runner, self.cumulative_iters)
-                    or self.is_last_iter(runner)):
-
-                # copy fp16 grads in the model to fp32 params in the optimizer
-                fp32_weights = []
-                for param_group in runner.optimizer.param_groups:
-                    fp32_weights += param_group['params']
-                self.copy_grads_to_fp32(runner.model, fp32_weights)
-                # allreduce grads
-                if self.distributed:
-                    allreduce_grads(fp32_weights, self.coalesce,
-                                    self.bucket_size_mb)
-
-                has_overflow = self.loss_scaler.has_overflow(fp32_weights)
-                # if has overflow, skip this iteration
-                if not has_overflow:
-                    # scale the gradients back
-                    for param in fp32_weights:
-                        if param.grad is not None:
-                            param.grad.div_(self.loss_scaler.loss_scale)
-                    if self.grad_clip is not None:
-                        grad_norm = self.clip_grads(fp32_weights)
-                        if grad_norm is not None:
-                            # Add grad norm to the logger
-                            runner.log_buffer.update(
-                                {'grad_norm': float(grad_norm)},
-                                runner.outputs['num_samples'])
-                    # update fp32 params
-                    runner.optimizer.step()
-                    # copy fp32 params to the fp16 model
-                    self.copy_params_to_fp16(runner.model, fp32_weights)
-                else:
-                    runner.logger.warning(
-                        'Check overflow, downscale loss scale '
-                        f'to {self.loss_scaler.cur_scale}')
-
-                self.loss_scaler.update_scale(has_overflow)
-
-                # save state_dict of loss_scaler
-                runner.meta.setdefault(
-                    'fp16', {})['loss_scaler'] = self.loss_scaler.state_dict()
-
-                # clear grads
-                runner.model.zero_grad()
-                runner.optimizer.zero_grad()
diff --git a/spaces/cubbycarlson/karl/app.py b/spaces/cubbycarlson/karl/app.py
deleted file mode 100644
index 38fdff39a157df2a7552e5da33d3aca7d816cd03..0000000000000000000000000000000000000000
--- a/spaces/cubbycarlson/karl/app.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import gradio as gr
-
-title = "GPT-J-6B"
-description = "What's up Karl?"
-article = "<p style='text-align: center'><a href='https://github.com/kingoflolz/mesh-transformer-jax' target='_blank'>GPT-J-6B: A 6 Billion Parameter Autoregressive Language Model</a></p>"
-examples = [
-    ['Karl is writing some amazing software'],
-    ["Cubby is also working on software but it is not a lot of natural language processing"],
-    ["Now they are going to work together on NLP as osteopathic physicians combining their powers"]
-]
-gr.Interface.load("huggingface/EleutherAI/gpt-j-6B", inputs=gr.inputs.Textbox(lines=5, label="Input Text"),title=title,description=description,article=article, examples=examples,enable_queue=True).launch()
\ No newline at end of file
diff --git a/spaces/danielsteinigen/NLP-Legal-Texts/util/__init__.py b/spaces/danielsteinigen/NLP-Legal-Texts/util/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/davidpiscasio/unpaired-img2img/options/train_options.py b/spaces/davidpiscasio/unpaired-img2img/options/train_options.py
deleted file mode 100644
index c8d5d2a92a916b385da08fa29a864547e114fb07..0000000000000000000000000000000000000000
--- a/spaces/davidpiscasio/unpaired-img2img/options/train_options.py
+++ /dev/null
@@ -1,40 +0,0 @@
-from .base_options import BaseOptions
-
-
-class TrainOptions(BaseOptions):
-    """This class includes training options.
-
-    It also includes shared options defined in BaseOptions.
-    """
-
-    def initialize(self, parser):
-        parser = BaseOptions.initialize(self, parser)
-        # visdom and HTML visualization parameters
-        parser.add_argument('--display_freq', type=int, default=400, help='frequency of showing training results on screen')
-        parser.add_argument('--display_ncols', type=int, default=4, help='if positive, display all images in a single visdom web panel with certain number of images per row.')
-        parser.add_argument('--display_id', type=int, default=1, help='window id of the web display')
-        parser.add_argument('--display_server', type=str, default="http://localhost", help='visdom server of the web display')
-        parser.add_argument('--display_env', type=str, default='main', help='visdom display environment name (default is "main")')
-        parser.add_argument('--display_port', type=int, default=8097, help='visdom port of the web display')
-        parser.add_argument('--update_html_freq', type=int, default=1000, help='frequency of saving training results to html')
-        parser.add_argument('--print_freq', type=int, default=100, help='frequency of showing training results on console')
-        parser.add_argument('--no_html', action='store_true', help='do not save intermediate training results to [opt.checkpoints_dir]/[opt.name]/web/')
-        # network saving and loading parameters
-        parser.add_argument('--save_latest_freq', type=int, default=5000, help='frequency of saving the latest results')
-        parser.add_argument('--save_epoch_freq', type=int, default=5, help='frequency of saving checkpoints at the end of epochs')
-        parser.add_argument('--save_by_iter', action='store_true', help='whether saves model by iteration')
-        parser.add_argument('--continue_train', action='store_true', help='continue training: load the latest model')
-        parser.add_argument('--epoch_count', type=int, default=1, help='the starting epoch count, we save the model by <epoch_count>, <epoch_count>+<save_latest_freq>, ...')
-        parser.add_argument('--phase', type=str, default='train', help='train, val, test, etc')
-        # training parameters
-        parser.add_argument('--n_epochs', type=int, default=100, help='number of epochs with the initial learning rate')
-        parser.add_argument('--n_epochs_decay', type=int, default=100, help='number of epochs to linearly decay learning rate to zero')
-        parser.add_argument('--beta1', type=float, default=0.5, help='momentum term of adam')
-        parser.add_argument('--lr', type=float, default=0.0002, help='initial learning rate for adam')
-        parser.add_argument('--gan_mode', type=str, default='lsgan', help='the type of GAN objective. [vanilla| lsgan | wgangp]. vanilla GAN loss is the cross-entropy objective used in the original GAN paper.')
-        parser.add_argument('--pool_size', type=int, default=50, help='the size of image buffer that stores previously generated images')
-        parser.add_argument('--lr_policy', type=str, default='linear', help='learning rate policy. [linear | step | plateau | cosine]')
-        parser.add_argument('--lr_decay_iters', type=int, default=50, help='multiply by a gamma every lr_decay_iters iterations')
-
-        self.isTrain = True
-        return parser
diff --git a/spaces/dawdqd/ChuanhuChatGPT/assets/html/footer.html b/spaces/dawdqd/ChuanhuChatGPT/assets/html/footer.html
deleted file mode 100644
index bca27bb8066dfab5cc0acf7be349a514de5f9a58..0000000000000000000000000000000000000000
--- a/spaces/dawdqd/ChuanhuChatGPT/assets/html/footer.html
+++ /dev/null
@@ -1 +0,0 @@
-<div class="versions">{versions}</div>
diff --git a/spaces/dawood/audioldm-text-to-audio-generation/audioldm/audio/audio_processing.py b/spaces/dawood/audioldm-text-to-audio-generation/audioldm/audio/audio_processing.py
deleted file mode 100644
index 77a4057aa82f226f68474f4c2a19eba84510d663..0000000000000000000000000000000000000000
--- a/spaces/dawood/audioldm-text-to-audio-generation/audioldm/audio/audio_processing.py
+++ /dev/null
@@ -1,100 +0,0 @@
-import torch
-import numpy as np
-import librosa.util as librosa_util
-from scipy.signal import get_window
-
-
-def window_sumsquare(
-    window,
-    n_frames,
-    hop_length,
-    win_length,
-    n_fft,
-    dtype=np.float32,
-    norm=None,
-):
-    """
-    # from librosa 0.6
-    Compute the sum-square envelope of a window function at a given hop length.
-
-    This is used to estimate modulation effects induced by windowing
-    observations in short-time fourier transforms.
-
-    Parameters
-    ----------
-    window : string, tuple, number, callable, or list-like
-        Window specification, as in `get_window`
-
-    n_frames : int > 0
-        The number of analysis frames
-
-    hop_length : int > 0
-        The number of samples to advance between frames
-
-    win_length : [optional]
-        The length of the window function.  By default, this matches `n_fft`.
-
-    n_fft : int > 0
-        The length of each analysis frame.
-
-    dtype : np.dtype
-        The data type of the output
-
-    Returns
-    -------
-    wss : np.ndarray, shape=`(n_fft + hop_length * (n_frames - 1))`
-        The sum-squared envelope of the window function
-    """
-    if win_length is None:
-        win_length = n_fft
-
-    n = n_fft + hop_length * (n_frames - 1)
-    x = np.zeros(n, dtype=dtype)
-
-    # Compute the squared window at the desired length
-    win_sq = get_window(window, win_length, fftbins=True)
-    win_sq = librosa_util.normalize(win_sq, norm=norm) ** 2
-    win_sq = librosa_util.pad_center(win_sq, n_fft)
-
-    # Fill the envelope
-    for i in range(n_frames):
-        sample = i * hop_length
-        x[sample : min(n, sample + n_fft)] += win_sq[: max(0, min(n_fft, n - sample))]
-    return x
-
-
-def griffin_lim(magnitudes, stft_fn, n_iters=30):
-    """
-    PARAMS
-    ------
-    magnitudes: spectrogram magnitudes
-    stft_fn: STFT class with transform (STFT) and inverse (ISTFT) methods
-    """
-
-    angles = np.angle(np.exp(2j * np.pi * np.random.rand(*magnitudes.size())))
-    angles = angles.astype(np.float32)
-    angles = torch.autograd.Variable(torch.from_numpy(angles))
-    signal = stft_fn.inverse(magnitudes, angles).squeeze(1)
-
-    for i in range(n_iters):
-        _, angles = stft_fn.transform(signal)
-        signal = stft_fn.inverse(magnitudes, angles).squeeze(1)
-    return signal
-
-
-def dynamic_range_compression(x, normalize_fun=torch.log, C=1, clip_val=1e-5):
-    """
-    PARAMS
-    ------
-    C: compression factor
-    """
-    return normalize_fun(torch.clamp(x, min=clip_val) * C)
-
-
-def dynamic_range_decompression(x, C=1):
-    """
-    PARAMS
-    ------
-    C: compression factor used to compress
-    """
-    return torch.exp(x) / C
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/web_routedef.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/web_routedef.py
deleted file mode 100644
index a1eb0a76549fbde5aa0c81f02b041b77bd91e0ad..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/web_routedef.py
+++ /dev/null
@@ -1,216 +0,0 @@
-import abc
-import os  # noqa
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Type,
-    Union,
-    overload,
-)
-
-import attr
-
-from . import hdrs
-from .abc import AbstractView
-from .typedefs import Handler, PathLike
-
-if TYPE_CHECKING:  # pragma: no cover
-    from .web_request import Request
-    from .web_response import StreamResponse
-    from .web_urldispatcher import AbstractRoute, UrlDispatcher
-else:
-    Request = StreamResponse = UrlDispatcher = AbstractRoute = None
-
-
-__all__ = (
-    "AbstractRouteDef",
-    "RouteDef",
-    "StaticDef",
-    "RouteTableDef",
-    "head",
-    "options",
-    "get",
-    "post",
-    "patch",
-    "put",
-    "delete",
-    "route",
-    "view",
-    "static",
-)
-
-
-class AbstractRouteDef(abc.ABC):
-    @abc.abstractmethod
-    def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
-        pass  # pragma: no cover
-
-
-_HandlerType = Union[Type[AbstractView], Handler]
-
-
-@attr.s(auto_attribs=True, frozen=True, repr=False, slots=True)
-class RouteDef(AbstractRouteDef):
-    method: str
-    path: str
-    handler: _HandlerType
-    kwargs: Dict[str, Any]
-
-    def __repr__(self) -> str:
-        info = []
-        for name, value in sorted(self.kwargs.items()):
-            info.append(f", {name}={value!r}")
-        return "<RouteDef {method} {path} -> {handler.__name__!r}" "{info}>".format(
-            method=self.method, path=self.path, handler=self.handler, info="".join(info)
-        )
-
-    def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
-        if self.method in hdrs.METH_ALL:
-            reg = getattr(router, "add_" + self.method.lower())
-            return [reg(self.path, self.handler, **self.kwargs)]
-        else:
-            return [
-                router.add_route(self.method, self.path, self.handler, **self.kwargs)
-            ]
-
-
-@attr.s(auto_attribs=True, frozen=True, repr=False, slots=True)
-class StaticDef(AbstractRouteDef):
-    prefix: str
-    path: PathLike
-    kwargs: Dict[str, Any]
-
-    def __repr__(self) -> str:
-        info = []
-        for name, value in sorted(self.kwargs.items()):
-            info.append(f", {name}={value!r}")
-        return "<StaticDef {prefix} -> {path}" "{info}>".format(
-            prefix=self.prefix, path=self.path, info="".join(info)
-        )
-
-    def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
-        resource = router.add_static(self.prefix, self.path, **self.kwargs)
-        routes = resource.get_info().get("routes", {})
-        return list(routes.values())
-
-
-def route(method: str, path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
-    return RouteDef(method, path, handler, kwargs)
-
-
-def head(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
-    return route(hdrs.METH_HEAD, path, handler, **kwargs)
-
-
-def options(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
-    return route(hdrs.METH_OPTIONS, path, handler, **kwargs)
-
-
-def get(
-    path: str,
-    handler: _HandlerType,
-    *,
-    name: Optional[str] = None,
-    allow_head: bool = True,
-    **kwargs: Any,
-) -> RouteDef:
-    return route(
-        hdrs.METH_GET, path, handler, name=name, allow_head=allow_head, **kwargs
-    )
-
-
-def post(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
-    return route(hdrs.METH_POST, path, handler, **kwargs)
-
-
-def put(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
-    return route(hdrs.METH_PUT, path, handler, **kwargs)
-
-
-def patch(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
-    return route(hdrs.METH_PATCH, path, handler, **kwargs)
-
-
-def delete(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
-    return route(hdrs.METH_DELETE, path, handler, **kwargs)
-
-
-def view(path: str, handler: Type[AbstractView], **kwargs: Any) -> RouteDef:
-    return route(hdrs.METH_ANY, path, handler, **kwargs)
-
-
-def static(prefix: str, path: PathLike, **kwargs: Any) -> StaticDef:
-    return StaticDef(prefix, path, kwargs)
-
-
-_Deco = Callable[[_HandlerType], _HandlerType]
-
-
-class RouteTableDef(Sequence[AbstractRouteDef]):
-    """Route definition table"""
-
-    def __init__(self) -> None:
-        self._items: List[AbstractRouteDef] = []
-
-    def __repr__(self) -> str:
-        return f"<RouteTableDef count={len(self._items)}>"
-
-    @overload
-    def __getitem__(self, index: int) -> AbstractRouteDef:
-        ...
-
-    @overload
-    def __getitem__(self, index: slice) -> List[AbstractRouteDef]:
-        ...
-
-    def __getitem__(self, index):  # type: ignore[no-untyped-def]
-        return self._items[index]
-
-    def __iter__(self) -> Iterator[AbstractRouteDef]:
-        return iter(self._items)
-
-    def __len__(self) -> int:
-        return len(self._items)
-
-    def __contains__(self, item: object) -> bool:
-        return item in self._items
-
-    def route(self, method: str, path: str, **kwargs: Any) -> _Deco:
-        def inner(handler: _HandlerType) -> _HandlerType:
-            self._items.append(RouteDef(method, path, handler, kwargs))
-            return handler
-
-        return inner
-
-    def head(self, path: str, **kwargs: Any) -> _Deco:
-        return self.route(hdrs.METH_HEAD, path, **kwargs)
-
-    def get(self, path: str, **kwargs: Any) -> _Deco:
-        return self.route(hdrs.METH_GET, path, **kwargs)
-
-    def post(self, path: str, **kwargs: Any) -> _Deco:
-        return self.route(hdrs.METH_POST, path, **kwargs)
-
-    def put(self, path: str, **kwargs: Any) -> _Deco:
-        return self.route(hdrs.METH_PUT, path, **kwargs)
-
-    def patch(self, path: str, **kwargs: Any) -> _Deco:
-        return self.route(hdrs.METH_PATCH, path, **kwargs)
-
-    def delete(self, path: str, **kwargs: Any) -> _Deco:
-        return self.route(hdrs.METH_DELETE, path, **kwargs)
-
-    def options(self, path: str, **kwargs: Any) -> _Deco:
-        return self.route(hdrs.METH_OPTIONS, path, **kwargs)
-
-    def view(self, path: str, **kwargs: Any) -> _Deco:
-        return self.route(hdrs.METH_ANY, path, **kwargs)
-
-    def static(self, prefix: str, path: PathLike, **kwargs: Any) -> None:
-        self._items.append(StaticDef(prefix, path, kwargs))
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/templates/frontend/assets/index-8a158e07.js b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/templates/frontend/assets/index-8a158e07.js
deleted file mode 100644
index de4d9b4ba199a0b8aa45225f9f3f654b59147908..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/templates/frontend/assets/index-8a158e07.js
+++ /dev/null
@@ -1,2 +0,0 @@
-import{E as u,L as v}from"./index-604e6cf5.js";import{s as k,t,h as S,L as w,i as z,w as x,f as R,a as U,b as _,I as T,x as V}from"./index-ba0b23cc.js";import"./index-39fce9e2.js";import"./Button-79f6e3bf.js";import"./Copy-77b3f70c.js";import"./Download-0afd7f1a.js";import"./BlockLabel-b1428685.js";import"./Empty-16d6169a.js";const Y=94,g=1,C=95,Z=96,f=2,$=[9,10,11,12,13,32,133,160,5760,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8232,8233,8239,8287,12288],G=58,N=40,X=95,q=91,c=45,E=46,j=35,D=37;function p(e){return e>=65&&e<=90||e>=97&&e<=122||e>=161}function I(e){return e>=48&&e<=57}const B=new u((e,o)=>{for(let r=!1,a=0,O=0;;O++){let{next:l}=e;if(p(l)||l==c||l==X||r&&I(l))!r&&(l!=c||O>0)&&(r=!0),a===O&&l==c&&a++,e.advance();else{r&&e.acceptToken(l==N?C:a==2&&o.canShift(f)?f:Z);break}}}),A=new u(e=>{if($.includes(e.peek(-1))){let{next:o}=e;(p(o)||o==X||o==j||o==E||o==q||o==G||o==c)&&e.acceptToken(Y)}}),F=new u(e=>{if(!$.includes(e.peek(-1))){let{next:o}=e;if(o==D&&(e.advance(),e.acceptToken(g)),p(o)){do e.advance();while(p(e.next));e.acceptToken(g)}}}),L=k({"AtKeyword import charset namespace keyframes media supports":t.definitionKeyword,"from to selector":t.keyword,NamespaceName:t.namespace,KeyframeName:t.labelName,TagName:t.tagName,ClassName:t.className,PseudoClassName:t.constant(t.className),IdName:t.labelName,"FeatureName PropertyName":t.propertyName,AttributeName:t.attributeName,NumberLiteral:t.number,KeywordQuery:t.keyword,UnaryQueryOp:t.operatorKeyword,"CallTag ValueName":t.atom,VariableName:t.variableName,Callee:t.operatorKeyword,Unit:t.unit,"UniversalSelector NestingSelector":t.definitionOperator,MatchOp:t.compareOperator,"ChildOp SiblingOp, LogicOp":t.logicOperator,BinOp:t.arithmeticOperator,Important:t.modifier,Comment:t.blockComment,ParenthesizedContent:t.special(t.name),ColorLiteral:t.color,StringLiteral:t.string,":":t.punctuation,"PseudoOp #":t.derefOperator,"; ,":t.separator,"( )":t.paren,"[ ]":t.squareBracket,"{ }":t.brace}),K={__proto__:null,lang:32,"nth-child":32,"nth-last-child":32,"nth-of-type":32,"nth-last-of-type":32,dir:32,"host-context":32,url:60,"url-prefix":60,domain:60,regexp:60,selector:134},J={__proto__:null,"@import":114,"@media":138,"@charset":142,"@namespace":146,"@keyframes":152,"@supports":164},H={__proto__:null,not:128,only:128,from:158,to:160},M=v.deserialize({version:14,states:"7WQYQ[OOO#_Q[OOOOQP'#Cd'#CdOOQP'#Cc'#CcO#fQ[O'#CfO$YQXO'#CaO$aQ[O'#ChO$lQ[O'#DPO$qQ[O'#DTOOQP'#Ed'#EdO$vQdO'#DeO%bQ[O'#DrO$vQdO'#DtO%sQ[O'#DvO&OQ[O'#DyO&TQ[O'#EPO&cQ[O'#EROOQS'#Ec'#EcOOQS'#ET'#ETQYQ[OOO&jQXO'#CdO'_QWO'#DaO'dQWO'#EjO'oQ[O'#EjQOQWOOOOQP'#Cg'#CgOOQP,59Q,59QO#fQ[O,59QO'yQ[O'#EWO(eQWO,58{O(mQ[O,59SO$lQ[O,59kO$qQ[O,59oO'yQ[O,59sO'yQ[O,59uO'yQ[O,59vO(xQ[O'#D`OOQS,58{,58{OOQP'#Ck'#CkOOQO'#C}'#C}OOQP,59S,59SO)PQWO,59SO)UQWO,59SOOQP'#DR'#DROOQP,59k,59kOOQO'#DV'#DVO)ZQ`O,59oOOQS'#Cp'#CpO$vQdO'#CqO)cQvO'#CsO*pQtO,5:POOQO'#Cx'#CxO)UQWO'#CwO+UQWO'#CyOOQS'#Eg'#EgOOQO'#Dh'#DhO+ZQ[O'#DoO+iQWO'#EkO&TQ[O'#DmO+wQWO'#DpOOQO'#El'#ElO(hQWO,5:^O+|QpO,5:`OOQS'#Dx'#DxO,UQWO,5:bO,ZQ[O,5:bOOQO'#D{'#D{O,cQWO,5:eO,hQWO,5:kO,pQWO,5:mOOQS-E8R-E8RO$vQdO,59{O,xQ[O'#EYO-VQWO,5;UO-VQWO,5;UOOQP1G.l1G.lO-|QXO,5:rOOQO-E8U-E8UOOQS1G.g1G.gOOQP1G.n1G.nO)PQWO1G.nO)UQWO1G.nOOQP1G/V1G/VO.ZQ`O1G/ZO.tQXO1G/_O/[QXO1G/aO/rQXO1G/bO0YQWO,59zO0_Q[O'#DOO0fQdO'#CoOOQP1G/Z1G/ZO$vQdO1G/ZO0mQpO,59]OOQS,59_,59_O$vQdO,59aO0uQWO1G/kOOQS,59c,59cO0zQ!bO,59eO1SQWO'#DhO1_QWO,5:TO1dQWO,5:ZO&TQ[O,5:VO&TQ[O'#EZO1lQWO,5;VO1wQWO,5:XO'yQ[O,5:[OOQS1G/x1G/xOOQS1G/z1G/zOOQS1G/|1G/|O2YQWO1G/|O2_QdO'#D|OOQS1G0P1G0POOQS1G0V1G0VOOQS1G0X1G0XO2mQtO1G/gOOQO,5:t,5:tO3TQ[O,5:tOOQO-E8W-E8WO3bQWO1G0pOOQP7+$Y7+$YOOQP7+$u7+$uO$vQdO7+$uOOQS1G/f1G/fO3mQXO'#EiO3tQWO,59jO3yQtO'#EUO4nQdO'#EfO4xQWO,59ZO4}QpO7+$uOOQS1G.w1G.wOOQS1G.{1G.{OOQS7+%V7+%VO5VQWO1G/PO$vQdO1G/oOOQO1G/u1G/uOOQO1G/q1G/qO5[QWO,5:uOOQO-E8X-E8XO5jQXO1G/vOOQS7+%h7+%hO5qQYO'#CsO(hQWO'#E[O5yQdO,5:hOOQS,5:h,5:hO6XQtO'#EXO$vQdO'#EXO7VQdO7+%ROOQO7+%R7+%ROOQO1G0`1G0`O7jQpO<<HaO7rQWO,5;TOOQP1G/U1G/UOOQS-E8S-E8SO$vQdO'#EVO7zQWO,5;QOOQT1G.u1G.uOOQP<<Ha<<HaOOQS7+$k7+$kO8SQdO7+%ZOOQO7+%b7+%bOOQS,5:v,5:vOOQS-E8Y-E8YOOQS1G0S1G0SO8ZQtO,5:sOOQS-E8V-E8VOOQO<<Hm<<HmOOQPAN={AN={O9XQdO,5:qOOQO-E8T-E8TOOQO<<Hu<<Hu",stateData:"9i~O#UOSROS~OUXOXXO]UO^UOtVOxWO!Y`O!ZYO!gZO!i[O!k]O!n^O!t_O#SQO#XSO~OQeOUXOXXO]UO^UOtVOxWO!Y`O!ZYO!gZO!i[O!k]O!n^O!t_O#SdO#XSO~O#P#^P~P!ZO#SiO~O]nO^nOplOtoOxpO|qO!PsO#QrO#XkO~O!RtO~P#kO`zO#RwO#SvO~O#S{O~O#S}O~OQ!WOb!QOf!WOh!WOn!VO#R!TO#S!PO#[!RO~Ob!YO!b![O!e!]O#S!XO!R#_P~Oh!bOn!VO#S!aO~O#S!dO~Ob!YO!b![O!e!]O#S!XO~O!W#_P~P%bO]WX]!UX^WXpWXtWXxWX|WX!PWX!RWX#QWX#XWX~O]!iO~O!W!jO#P#^X!Q#^X~O#P#^X!Q#^X~P!ZOUXOXXO]UO^UOtVOxWO#SQO#XSO~OplO!RtO~O`!sO#RwO#SvO~O!Q#^P~P!ZOb!zO~Ob!{O~Ov!|Oz!}O~OP#PObgXjgX!WgX!bgX!egX#SgXagXQgXfgXhgXngXpgX!VgX#PgX#RgX#[gXvgX!QgX~Ob!YOj#QO!b![O!e!]O#S!XO!W#_P~Ob#TO~Ob!YO!b![O!e!]O#S#UO~Op#YO!`#XO!R#_X!W#_X~Ob#]O~Oj#QO!W#_O~O!W#`O~Oh#aOn!VO~O!R#bO~O!RtO!`#XO~O!RtO!W#eO~O!W!|X#P!|X!Q!|X~P!ZO!W!jO#P#^a!Q#^a~O]nO^nOtoOxpO|qO!PsO#QrO#XkO~Op!za!R!zaa!za~P-bOv#lOz#mO~O]nO^nOtoOxpO#XkO~Op{i|{i!P{i!R{i#Q{ia{i~P.cOp}i|}i!P}i!R}i#Q}ia}i~P.cOp!Oi|!Oi!P!Oi!R!Oi#Q!Oia!Oi~P.cO!Q#nO~Oa#]P~P'yOa#YP~P$vOa#uOj#QO~O!W#wO~Oh#xOo#xO~O]!^Xa![X!`![X~O]#yO~Oa#zO!`#XO~Op#YO!R#_a!W#_a~O!`#XOp!aa!R!aa!W!aaa!aa~O!W$PO~O!Q$TO!q$RO!r$RO#[$QO~Oj#QOp$VO!V$XO!W!Ti#P!Ti!Q!Ti~P$vO!W!|a#P!|a!Q!|a~P!ZO!W!jO#P#^i!Q#^i~Oa#]X~P#kOa$]O~Oj#QOQ!xXa!xXb!xXf!xXh!xXn!xXp!xX#R!xX#S!xX#[!xX~Op$_Oa#YX~P$vOa$aO~Oj#QOv$bO~Oa$cO~O!`#XOp!}a!R!}a!W!}a~Oa$eO~P-bOP#PO!RgX~O!Q$hO!q$RO!r$RO#[$QO~Oj#QOQ!{Xb!{Xf!{Xh!{Xn!{Xp!{X!V!{X!W!{X#P!{X#R!{X#S!{X#[!{X!Q!{X~Op$VO!V$kO!W!Tq#P!Tq!Q!Tq~P$vOj#QOv$lO~OplOa#]a~Op$_Oa#Ya~Oa$oO~P$vOj#QOQ!{ab!{af!{ah!{an!{ap!{a!V!{a!W!{a#P!{a#R!{a#S!{a#[!{a!Q!{a~Oa!yap!ya~P$vOo#[j!Pj~",goto:",`#aPPPPP#bP#k#zP#k$Z#kPP$aPPP$g$p$pP%SP$pP$p%j%|PPP&f&l#kP&rP#kP&xP#kP#k#kPPP'O'b'oPP#bPP'v'v(Q'vP'vP'v'vP#bP#bP#bP(T#bP(W(ZPP#bP#bP(^(m({)R)])c)m)sPPPPPP)y*SP*o*rP+h+k+q+z_aOPcgt!j#hkXOPcglqrst!j!z#]#hkROPcglqrst!j!z#]#hQjSR!mkQxUR!qnQ!qzQ#S!UR#k!sq!WY[!Q!i!{!}#Q#f#m#r#y$V$W$_$d$mp!WY[!Q!i!{!}#Q#f#m#r#y$V$W$_$d$mT$R#b$Sq!UY[!Q!i!{!}#Q#f#m#r#y$V$W$_$d$mp!WY[!Q!i!{!}#Q#f#m#r#y$V$W$_$d$mQ!b]R#a!cQyUR!rnQ!qyR#k!rQ|VR!toQ!OWR!upQuTQ!pmQ#^!_Q#d!fQ#e!gR$f$RSfPtQ!lgQ#g!jR$Y#hZePgt!j#ha!^Z_`!S!Y![#X#YR#V!YR!c]R!e^R#c!eQcOSgPtU!hcg#hR#h!jQ#r!{U$^#r$d$mQ$d#yR$m$_Q$`#rR$n$`QmTS!om$[R$[#oQ$W#fR$j$WQ!kfS#i!k#jR#j!lQ#Z!ZR#}#ZQ$S#bR$g$S_bOPcgt!j#h^TOPcgt!j#hQ!nlQ!vqQ!wrQ!xsQ#o!zR$O#]R#s!{Q!SYQ!`[Q#O!QQ#f!i[#q!{#r#y$_$d$mQ#t!}Q#v#QS$U#f$WQ$Z#mR$i$VR#p!zQhPR!ytQ!_ZQ!g`R#R!SU!ZZ`!SQ!f_Q#W!YQ#[![Q#{#XR#|#Y",nodeNames:"⚠ Unit VariableName Comment StyleSheet RuleSet UniversalSelector TagSelector TagName NestingSelector ClassSelector ClassName PseudoClassSelector : :: PseudoClassName PseudoClassName ) ( ArgList ValueName ParenthesizedValue ColorLiteral NumberLiteral StringLiteral BinaryExpression BinOp CallExpression Callee CallLiteral CallTag ParenthesizedContent , PseudoClassName ArgList IdSelector # IdName ] AttributeSelector [ AttributeName MatchOp ChildSelector ChildOp DescendantSelector SiblingSelector SiblingOp } { Block Declaration PropertyName Important ; ImportStatement AtKeyword import KeywordQuery FeatureQuery FeatureName BinaryQuery LogicOp UnaryQuery UnaryQueryOp ParenthesizedQuery SelectorQuery selector MediaStatement media CharsetStatement charset NamespaceStatement namespace NamespaceName KeyframesStatement keyframes KeyframeName KeyframeList from to SupportsStatement supports AtRule Styles",maxTerm:108,nodeProps:[["openedBy",17,"(",48,"{"],["closedBy",18,")",49,"}"]],propSources:[L],skippedNodes:[0,3],repeatNodeCount:8,tokenData:"Lq~R!^OX$}X^%u^p$}pq%uqr)Xrs.Rst/utu6duv$}vw7^wx7oxy9^yz9oz{9t{|:_|}?Q}!O?c!O!P@Q!P!Q@i!Q![Cu![!]Dp!]!^El!^!_$}!_!`E}!`!aF`!a!b$}!b!cG[!c!}$}!}#OHt#O#P$}#P#QIV#Q#R6d#R#T$}#T#UIh#U#c$}#c#dJy#d#o$}#o#pK`#p#q6d#q#rKq#r#sLS#s#y$}#y#z%u#z$f$}$f$g%u$g#BY$}#BY#BZ%u#BZ$IS$}$IS$I_%u$I_$I|$}$I|$JO%u$JO$JT$}$JT$JU%u$JU$KV$}$KV$KW%u$KW&FU$}&FU&FV%u&FV;'S$};'S;=`Lk<%lO$}W%QSOy%^z;'S%^;'S;=`%o<%lO%^W%cSoWOy%^z;'S%^;'S;=`%o<%lO%^W%rP;=`<%l%^~%zh#U~OX%^X^'f^p%^pq'fqy%^z#y%^#y#z'f#z$f%^$f$g'f$g#BY%^#BY#BZ'f#BZ$IS%^$IS$I_'f$I_$I|%^$I|$JO'f$JO$JT%^$JT$JU'f$JU$KV%^$KV$KW'f$KW&FU%^&FU&FV'f&FV;'S%^;'S;=`%o<%lO%^~'mh#U~oWOX%^X^'f^p%^pq'fqy%^z#y%^#y#z'f#z$f%^$f$g'f$g#BY%^#BY#BZ'f#BZ$IS%^$IS$I_'f$I_$I|%^$I|$JO'f$JO$JT%^$JT$JU'f$JU$KV%^$KV$KW'f$KW&FU%^&FU&FV'f&FV;'S%^;'S;=`%o<%lO%^^)[UOy%^z#]%^#]#^)n#^;'S%^;'S;=`%o<%lO%^^)sUoWOy%^z#a%^#a#b*V#b;'S%^;'S;=`%o<%lO%^^*[UoWOy%^z#d%^#d#e*n#e;'S%^;'S;=`%o<%lO%^^*sUoWOy%^z#c%^#c#d+V#d;'S%^;'S;=`%o<%lO%^^+[UoWOy%^z#f%^#f#g+n#g;'S%^;'S;=`%o<%lO%^^+sUoWOy%^z#h%^#h#i,V#i;'S%^;'S;=`%o<%lO%^^,[UoWOy%^z#T%^#T#U,n#U;'S%^;'S;=`%o<%lO%^^,sUoWOy%^z#b%^#b#c-V#c;'S%^;'S;=`%o<%lO%^^-[UoWOy%^z#h%^#h#i-n#i;'S%^;'S;=`%o<%lO%^^-uS!VUoWOy%^z;'S%^;'S;=`%o<%lO%^~.UWOY.RZr.Rrs.ns#O.R#O#P.s#P;'S.R;'S;=`/o<%lO.R~.sOh~~.vRO;'S.R;'S;=`/P;=`O.R~/SXOY.RZr.Rrs.ns#O.R#O#P.s#P;'S.R;'S;=`/o;=`<%l.R<%lO.R~/rP;=`<%l.R_/zYtPOy%^z!Q%^!Q![0j![!c%^!c!i0j!i#T%^#T#Z0j#Z;'S%^;'S;=`%o<%lO%^^0oYoWOy%^z!Q%^!Q![1_![!c%^!c!i1_!i#T%^#T#Z1_#Z;'S%^;'S;=`%o<%lO%^^1dYoWOy%^z!Q%^!Q![2S![!c%^!c!i2S!i#T%^#T#Z2S#Z;'S%^;'S;=`%o<%lO%^^2ZYfUoWOy%^z!Q%^!Q![2y![!c%^!c!i2y!i#T%^#T#Z2y#Z;'S%^;'S;=`%o<%lO%^^3QYfUoWOy%^z!Q%^!Q![3p![!c%^!c!i3p!i#T%^#T#Z3p#Z;'S%^;'S;=`%o<%lO%^^3uYoWOy%^z!Q%^!Q![4e![!c%^!c!i4e!i#T%^#T#Z4e#Z;'S%^;'S;=`%o<%lO%^^4lYfUoWOy%^z!Q%^!Q![5[![!c%^!c!i5[!i#T%^#T#Z5[#Z;'S%^;'S;=`%o<%lO%^^5aYoWOy%^z!Q%^!Q![6P![!c%^!c!i6P!i#T%^#T#Z6P#Z;'S%^;'S;=`%o<%lO%^^6WSfUoWOy%^z;'S%^;'S;=`%o<%lO%^Y6gUOy%^z!_%^!_!`6y!`;'S%^;'S;=`%o<%lO%^Y7QSzQoWOy%^z;'S%^;'S;=`%o<%lO%^X7cSXPOy%^z;'S%^;'S;=`%o<%lO%^~7rWOY7oZw7owx.nx#O7o#O#P8[#P;'S7o;'S;=`9W<%lO7o~8_RO;'S7o;'S;=`8h;=`O7o~8kXOY7oZw7owx.nx#O7o#O#P8[#P;'S7o;'S;=`9W;=`<%l7o<%lO7o~9ZP;=`<%l7o_9cSbVOy%^z;'S%^;'S;=`%o<%lO%^~9tOa~_9{UUPjSOy%^z!_%^!_!`6y!`;'S%^;'S;=`%o<%lO%^_:fWjS!PPOy%^z!O%^!O!P;O!P!Q%^!Q![>T![;'S%^;'S;=`%o<%lO%^^;TUoWOy%^z!Q%^!Q![;g![;'S%^;'S;=`%o<%lO%^^;nYoW#[UOy%^z!Q%^!Q![;g![!g%^!g!h<^!h#X%^#X#Y<^#Y;'S%^;'S;=`%o<%lO%^^<cYoWOy%^z{%^{|=R|}%^}!O=R!O!Q%^!Q![=j![;'S%^;'S;=`%o<%lO%^^=WUoWOy%^z!Q%^!Q![=j![;'S%^;'S;=`%o<%lO%^^=qUoW#[UOy%^z!Q%^!Q![=j![;'S%^;'S;=`%o<%lO%^^>[[oW#[UOy%^z!O%^!O!P;g!P!Q%^!Q![>T![!g%^!g!h<^!h#X%^#X#Y<^#Y;'S%^;'S;=`%o<%lO%^_?VSpVOy%^z;'S%^;'S;=`%o<%lO%^^?hWjSOy%^z!O%^!O!P;O!P!Q%^!Q![>T![;'S%^;'S;=`%o<%lO%^_@VU#XPOy%^z!Q%^!Q![;g![;'S%^;'S;=`%o<%lO%^~@nTjSOy%^z{@}{;'S%^;'S;=`%o<%lO%^~ASUoWOy@}yzAfz{Bm{;'S@};'S;=`Co<%lO@}~AiTOzAfz{Ax{;'SAf;'S;=`Bg<%lOAf~A{VOzAfz{Ax{!PAf!P!QBb!Q;'SAf;'S;=`Bg<%lOAf~BgOR~~BjP;=`<%lAf~BrWoWOy@}yzAfz{Bm{!P@}!P!QC[!Q;'S@};'S;=`Co<%lO@}~CcSoWR~Oy%^z;'S%^;'S;=`%o<%lO%^~CrP;=`<%l@}^Cz[#[UOy%^z!O%^!O!P;g!P!Q%^!Q![>T![!g%^!g!h<^!h#X%^#X#Y<^#Y;'S%^;'S;=`%o<%lO%^XDuU]POy%^z![%^![!]EX!];'S%^;'S;=`%o<%lO%^XE`S^PoWOy%^z;'S%^;'S;=`%o<%lO%^_EqS!WVOy%^z;'S%^;'S;=`%o<%lO%^YFSSzQOy%^z;'S%^;'S;=`%o<%lO%^XFeU|POy%^z!`%^!`!aFw!a;'S%^;'S;=`%o<%lO%^XGOS|PoWOy%^z;'S%^;'S;=`%o<%lO%^XG_WOy%^z!c%^!c!}Gw!}#T%^#T#oGw#o;'S%^;'S;=`%o<%lO%^XHO[!YPoWOy%^z}%^}!OGw!O!Q%^!Q![Gw![!c%^!c!}Gw!}#T%^#T#oGw#o;'S%^;'S;=`%o<%lO%^XHySxPOy%^z;'S%^;'S;=`%o<%lO%^^I[SvUOy%^z;'S%^;'S;=`%o<%lO%^XIkUOy%^z#b%^#b#cI}#c;'S%^;'S;=`%o<%lO%^XJSUoWOy%^z#W%^#W#XJf#X;'S%^;'S;=`%o<%lO%^XJmS!`PoWOy%^z;'S%^;'S;=`%o<%lO%^XJ|UOy%^z#f%^#f#gJf#g;'S%^;'S;=`%o<%lO%^XKeS!RPOy%^z;'S%^;'S;=`%o<%lO%^_KvS!QVOy%^z;'S%^;'S;=`%o<%lO%^ZLXU!PPOy%^z!_%^!_!`6y!`;'S%^;'S;=`%o<%lO%^WLnP;=`<%l$}",tokenizers:[A,F,B,0,1,2,3],topRules:{StyleSheet:[0,4],Styles:[1,84]},specialized:[{term:95,get:e=>K[e]||-1},{term:56,get:e=>J[e]||-1},{term:96,get:e=>H[e]||-1}],tokenPrec:1123});let Q=null;function m(){if(!Q&&typeof document=="object"&&document.body){let{style:e}=document.body,o=[],r=new Set;for(let a in e)a!="cssText"&&a!="cssFloat"&&typeof e[a]=="string"&&(/[A-Z]/.test(a)&&(a=a.replace(/[A-Z]/g,O=>"-"+O.toLowerCase())),r.has(a)||(o.push(a),r.add(a)));Q=o.sort().map(a=>({type:"property",label:a}))}return Q||[]}const h=["active","after","any-link","autofill","backdrop","before","checked","cue","default","defined","disabled","empty","enabled","file-selector-button","first","first-child","first-letter","first-line","first-of-type","focus","focus-visible","focus-within","fullscreen","has","host","host-context","hover","in-range","indeterminate","invalid","is","lang","last-child","last-of-type","left","link","marker","modal","not","nth-child","nth-last-child","nth-last-of-type","nth-of-type","only-child","only-of-type","optional","out-of-range","part","placeholder","placeholder-shown","read-only","read-write","required","right","root","scope","selection","slotted","target","target-text","valid","visited","where"].map(e=>({type:"class",label:e})),b=["above","absolute","activeborder","additive","activecaption","after-white-space","ahead","alias","all","all-scroll","alphabetic","alternate","always","antialiased","appworkspace","asterisks","attr","auto","auto-flow","avoid","avoid-column","avoid-page","avoid-region","axis-pan","background","backwards","baseline","below","bidi-override","blink","block","block-axis","bold","bolder","border","border-box","both","bottom","break","break-all","break-word","bullets","button","button-bevel","buttonface","buttonhighlight","buttonshadow","buttontext","calc","capitalize","caps-lock-indicator","caption","captiontext","caret","cell","center","checkbox","circle","cjk-decimal","clear","clip","close-quote","col-resize","collapse","color","color-burn","color-dodge","column","column-reverse","compact","condensed","contain","content","contents","content-box","context-menu","continuous","copy","counter","counters","cover","crop","cross","crosshair","currentcolor","cursive","cyclic","darken","dashed","decimal","decimal-leading-zero","default","default-button","dense","destination-atop","destination-in","destination-out","destination-over","difference","disc","discard","disclosure-closed","disclosure-open","document","dot-dash","dot-dot-dash","dotted","double","down","e-resize","ease","ease-in","ease-in-out","ease-out","element","ellipse","ellipsis","embed","end","ethiopic-abegede-gez","ethiopic-halehame-aa-er","ethiopic-halehame-gez","ew-resize","exclusion","expanded","extends","extra-condensed","extra-expanded","fantasy","fast","fill","fill-box","fixed","flat","flex","flex-end","flex-start","footnotes","forwards","from","geometricPrecision","graytext","grid","groove","hand","hard-light","help","hidden","hide","higher","highlight","highlighttext","horizontal","hsl","hsla","hue","icon","ignore","inactiveborder","inactivecaption","inactivecaptiontext","infinite","infobackground","infotext","inherit","initial","inline","inline-axis","inline-block","inline-flex","inline-grid","inline-table","inset","inside","intrinsic","invert","italic","justify","keep-all","landscape","large","larger","left","level","lighter","lighten","line-through","linear","linear-gradient","lines","list-item","listbox","listitem","local","logical","loud","lower","lower-hexadecimal","lower-latin","lower-norwegian","lowercase","ltr","luminosity","manipulation","match","matrix","matrix3d","medium","menu","menutext","message-box","middle","min-intrinsic","mix","monospace","move","multiple","multiple_mask_images","multiply","n-resize","narrower","ne-resize","nesw-resize","no-close-quote","no-drop","no-open-quote","no-repeat","none","normal","not-allowed","nowrap","ns-resize","numbers","numeric","nw-resize","nwse-resize","oblique","opacity","open-quote","optimizeLegibility","optimizeSpeed","outset","outside","outside-shape","overlay","overline","padding","padding-box","painted","page","paused","perspective","pinch-zoom","plus-darker","plus-lighter","pointer","polygon","portrait","pre","pre-line","pre-wrap","preserve-3d","progress","push-button","radial-gradient","radio","read-only","read-write","read-write-plaintext-only","rectangle","region","relative","repeat","repeating-linear-gradient","repeating-radial-gradient","repeat-x","repeat-y","reset","reverse","rgb","rgba","ridge","right","rotate","rotate3d","rotateX","rotateY","rotateZ","round","row","row-resize","row-reverse","rtl","run-in","running","s-resize","sans-serif","saturation","scale","scale3d","scaleX","scaleY","scaleZ","screen","scroll","scrollbar","scroll-position","se-resize","self-start","self-end","semi-condensed","semi-expanded","separate","serif","show","single","skew","skewX","skewY","skip-white-space","slide","slider-horizontal","slider-vertical","sliderthumb-horizontal","sliderthumb-vertical","slow","small","small-caps","small-caption","smaller","soft-light","solid","source-atop","source-in","source-out","source-over","space","space-around","space-between","space-evenly","spell-out","square","start","static","status-bar","stretch","stroke","stroke-box","sub","subpixel-antialiased","svg_masks","super","sw-resize","symbolic","symbols","system-ui","table","table-caption","table-cell","table-column","table-column-group","table-footer-group","table-header-group","table-row","table-row-group","text","text-bottom","text-top","textarea","textfield","thick","thin","threeddarkshadow","threedface","threedhighlight","threedlightshadow","threedshadow","to","top","transform","translate","translate3d","translateX","translateY","translateZ","transparent","ultra-condensed","ultra-expanded","underline","unidirectional-pan","unset","up","upper-latin","uppercase","url","var","vertical","vertical-text","view-box","visible","visibleFill","visiblePainted","visibleStroke","visual","w-resize","wait","wave","wider","window","windowframe","windowtext","words","wrap","wrap-reverse","x-large","x-small","xor","xx-large","xx-small"].map(e=>({type:"keyword",label:e})).concat(["aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","grey","green","greenyellow","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen"].map(e=>({type:"constant",label:e}))),ee=["a","abbr","address","article","aside","b","bdi","bdo","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","dd","del","details","dfn","dialog","div","dl","dt","em","figcaption","figure","footer","form","header","hgroup","h1","h2","h3","h4","h5","h6","hr","html","i","iframe","img","input","ins","kbd","label","legend","li","main","meter","nav","ol","output","p","pre","ruby","section","select","small","source","span","strong","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","tr","u","ul"].map(e=>({type:"type",label:e})),n=/^(\w[\w-]*|-\w[\w-]*|)$/,ae=/^-(-[\w-]*)?$/;function Oe(e,o){var r;if((e.name=="("||e.type.isError)&&(e=e.parent||e),e.name!="ArgList")return!1;let a=(r=e.parent)===null||r===void 0?void 0:r.firstChild;return a?.name!="Callee"?!1:o.sliceString(a.from,a.to)=="var"}const y=new V,te=["Declaration"];function W(e,o){if(o.to-o.from>4096){let r=y.get(o);if(r)return r;let a=[],O=new Set,l=o.cursor(T.IncludeAnonymous);if(l.firstChild())do for(let i of W(e,l.node))O.has(i.label)||(O.add(i.label),a.push(i));while(l.nextSibling());return y.set(o,a),a}else{let r=[],a=new Set;return o.cursor().iterate(O=>{var l;if(O.name=="VariableName"&&O.matchContext(te)&&((l=O.node.nextSibling)===null||l===void 0?void 0:l.name)==":"){let i=e.sliceString(O.from,O.to);a.has(i)||(a.add(i),r.push({label:i,type:"variable"}))}}),r}}const oe=e=>{var o;let{state:r,pos:a}=e,O=S(r).resolveInner(a,-1),l=O.type.isError&&O.from==O.to-1&&r.doc.sliceString(O.from,O.to)=="-";if(O.name=="PropertyName"||l&&((o=O.parent)===null||o===void 0?void 0:o.name)=="Block")return{from:O.from,options:m(),validFor:n};if(O.name=="ValueName")return{from:O.from,options:b,validFor:n};if(O.name=="PseudoClassName")return{from:O.from,options:h,validFor:n};if(O.name=="VariableName"||(e.explicit||l)&&Oe(O,r.doc))return{from:O.name=="VariableName"?O.from:a,options:W(r.doc,S(r).topNode),validFor:ae};if(O.name=="TagName"){for(let{parent:d}=O;d;d=d.parent)if(d.name=="Block")return{from:O.from,options:m(),validFor:n};return{from:O.from,options:ee,validFor:n}}if(!e.explicit)return null;let i=O.resolve(a),s=i.childBefore(a);return s&&s.name==":"&&i.name=="PseudoClassSelector"?{from:a,options:h,validFor:n}:s&&s.name==":"&&i.name=="Declaration"||i.name=="ArgList"?{from:a,options:b,validFor:n}:i.name=="Block"?{from:a,options:m(),validFor:n}:null},P=w.define({name:"css",parser:M.configure({props:[z.add({Declaration:x()}),R.add({Block:U})]}),languageData:{commentTokens:{block:{open:"/*",close:"*/"}},indentOnInput:/^\s*\}$/,wordChars:"-"}});function Qe(){return new _(P,P.data.of({autocomplete:oe}))}export{Qe as css,oe as cssCompletionSource,P as cssLanguage};
-//# sourceMappingURL=index-8a158e07.js.map
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/themes/utils/theme_dropdown.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/themes/utils/theme_dropdown.py
deleted file mode 100644
index c3d21bba7784a0b8b4bfd989cd83ccda52c4fdbc..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/themes/utils/theme_dropdown.py
+++ /dev/null
@@ -1,57 +0,0 @@
-import os
-import pathlib
-
-from gradio.themes.utils import ThemeAsset
-
-
-def create_theme_dropdown():
-    import gradio as gr
-
-    asset_path = pathlib.Path() / "themes"
-    themes = []
-    for theme_asset in os.listdir(str(asset_path)):
-        themes.append(
-            (ThemeAsset(theme_asset), gr.Theme.load(str(asset_path / theme_asset)))
-        )
-
-    def make_else_if(theme_asset):
-        return f"""
-        else if (theme == '{str(theme_asset[0].version)}') {{
-            var theme_css = `{theme_asset[1]._get_theme_css()}`
-        }}"""
-
-    head, tail = themes[0], themes[1:]
-    if_statement = f"""
-        if (theme == "{str(head[0].version)}") {{
-            var theme_css = `{head[1]._get_theme_css()}`
-        }} {" ".join(make_else_if(t) for t in tail)}
-    """
-
-    latest_to_oldest = sorted([t[0] for t in themes], key=lambda asset: asset.version)[
-        ::-1
-    ]
-    latest_to_oldest = [str(t.version) for t in latest_to_oldest]
-
-    component = gr.Dropdown(
-        choices=latest_to_oldest,
-        value=latest_to_oldest[0],
-        render=False,
-        label="Select Version",
-    ).style(container=False)
-
-    return (
-        component,
-        f"""
-        (theme) => {{
-            if (!document.querySelector('.theme-css')) {{
-                var theme_elem = document.createElement('style');
-                theme_elem.classList.add('theme-css');
-                document.head.appendChild(theme_elem);
-            }} else {{
-                var theme_elem = document.querySelector('.theme-css');
-            }}
-            {if_statement}
-            theme_elem.innerHTML = theme_css;
-        }}
-    """,
-    )
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/h11/tests/test_receivebuffer.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/h11/tests/test_receivebuffer.py
deleted file mode 100644
index 21a3870b6be9a6a365037326c2085ff2715022cc..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/h11/tests/test_receivebuffer.py
+++ /dev/null
@@ -1,135 +0,0 @@
-import re
-from typing import Tuple
-
-import pytest
-
-from .._receivebuffer import ReceiveBuffer
-
-
-def test_receivebuffer() -> None:
-    b = ReceiveBuffer()
-    assert not b
-    assert len(b) == 0
-    assert bytes(b) == b""
-
-    b += b"123"
-    assert b
-    assert len(b) == 3
-    assert bytes(b) == b"123"
-
-    assert bytes(b) == b"123"
-
-    assert b.maybe_extract_at_most(2) == b"12"
-    assert b
-    assert len(b) == 1
-    assert bytes(b) == b"3"
-
-    assert bytes(b) == b"3"
-
-    assert b.maybe_extract_at_most(10) == b"3"
-    assert bytes(b) == b""
-
-    assert b.maybe_extract_at_most(10) is None
-    assert not b
-
-    ################################################################
-    # maybe_extract_until_next
-    ################################################################
-
-    b += b"123\n456\r\n789\r\n"
-
-    assert b.maybe_extract_next_line() == b"123\n456\r\n"
-    assert bytes(b) == b"789\r\n"
-
-    assert b.maybe_extract_next_line() == b"789\r\n"
-    assert bytes(b) == b""
-
-    b += b"12\r"
-    assert b.maybe_extract_next_line() is None
-    assert bytes(b) == b"12\r"
-
-    b += b"345\n\r"
-    assert b.maybe_extract_next_line() is None
-    assert bytes(b) == b"12\r345\n\r"
-
-    # here we stopped at the middle of b"\r\n" delimiter
-
-    b += b"\n6789aaa123\r\n"
-    assert b.maybe_extract_next_line() == b"12\r345\n\r\n"
-    assert b.maybe_extract_next_line() == b"6789aaa123\r\n"
-    assert b.maybe_extract_next_line() is None
-    assert bytes(b) == b""
-
-    ################################################################
-    # maybe_extract_lines
-    ################################################################
-
-    b += b"123\r\na: b\r\nfoo:bar\r\n\r\ntrailing"
-    lines = b.maybe_extract_lines()
-    assert lines == [b"123", b"a: b", b"foo:bar"]
-    assert bytes(b) == b"trailing"
-
-    assert b.maybe_extract_lines() is None
-
-    b += b"\r\n\r"
-    assert b.maybe_extract_lines() is None
-
-    assert b.maybe_extract_at_most(100) == b"trailing\r\n\r"
-    assert not b
-
-    # Empty body case (as happens at the end of chunked encoding if there are
-    # no trailing headers, e.g.)
-    b += b"\r\ntrailing"
-    assert b.maybe_extract_lines() == []
-    assert bytes(b) == b"trailing"
-
-
-@pytest.mark.parametrize(
-    "data",
-    [
-        pytest.param(
-            (
-                b"HTTP/1.1 200 OK\r\n",
-                b"Content-type: text/plain\r\n",
-                b"Connection: close\r\n",
-                b"\r\n",
-                b"Some body",
-            ),
-            id="with_crlf_delimiter",
-        ),
-        pytest.param(
-            (
-                b"HTTP/1.1 200 OK\n",
-                b"Content-type: text/plain\n",
-                b"Connection: close\n",
-                b"\n",
-                b"Some body",
-            ),
-            id="with_lf_only_delimiter",
-        ),
-        pytest.param(
-            (
-                b"HTTP/1.1 200 OK\n",
-                b"Content-type: text/plain\r\n",
-                b"Connection: close\n",
-                b"\n",
-                b"Some body",
-            ),
-            id="with_mixed_crlf_and_lf",
-        ),
-    ],
-)
-def test_receivebuffer_for_invalid_delimiter(data: Tuple[bytes]) -> None:
-    b = ReceiveBuffer()
-
-    for line in data:
-        b += line
-
-    lines = b.maybe_extract_lines()
-
-    assert lines == [
-        b"HTTP/1.1 200 OK",
-        b"Content-type: text/plain",
-        b"Connection: close",
-    ]
-    assert bytes(b) == b"Some body"
diff --git a/spaces/declare-lab/tango/diffusers/src/diffusers/utils/.ipynb_checkpoints/__init__-checkpoint.py b/spaces/declare-lab/tango/diffusers/src/diffusers/utils/.ipynb_checkpoints/__init__-checkpoint.py
deleted file mode 100644
index 3a1103ac1adfd346c200e2cccaa2f6f80b8c791b..0000000000000000000000000000000000000000
--- a/spaces/declare-lab/tango/diffusers/src/diffusers/utils/.ipynb_checkpoints/__init__-checkpoint.py
+++ /dev/null
@@ -1,115 +0,0 @@
-# Copyright 2023 The HuggingFace Inc. team. 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 os
-
-from packaging import version
-
-from .. import __version__
-from .accelerate_utils import apply_forward_hook
-from .constants import (
-    CONFIG_NAME,
-    DEPRECATED_REVISION_ARGS,
-    DIFFUSERS_CACHE,
-    DIFFUSERS_DYNAMIC_MODULE_NAME,
-    FLAX_WEIGHTS_NAME,
-    HF_MODULES_CACHE,
-    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
-    ONNX_EXTERNAL_WEIGHTS_NAME,
-    ONNX_WEIGHTS_NAME,
-    SAFETENSORS_WEIGHTS_NAME,
-    WEIGHTS_NAME,
-)
-from .deprecation_utils import deprecate
-from .doc_utils import replace_example_docstring
-from .dynamic_modules_utils import get_class_from_dynamic_module
-from .hub_utils import (
-    HF_HUB_OFFLINE,
-    _add_variant,
-    _get_model_file,
-    extract_commit_hash,
-    http_user_agent,
-)
-from .import_utils import (
-    ENV_VARS_TRUE_AND_AUTO_VALUES,
-    ENV_VARS_TRUE_VALUES,
-    USE_JAX,
-    USE_TF,
-    USE_TORCH,
-    DummyObject,
-    OptionalDependencyNotAvailable,
-    is_accelerate_available,
-    is_accelerate_version,
-    is_flax_available,
-    is_inflect_available,
-    is_k_diffusion_available,
-    is_k_diffusion_version,
-    is_librosa_available,
-    is_note_seq_available,
-    is_omegaconf_available,
-    is_onnx_available,
-    is_safetensors_available,
-    is_scipy_available,
-    is_tensorboard_available,
-    is_tf_available,
-    is_torch_available,
-    is_torch_version,
-    is_transformers_available,
-    is_transformers_version,
-    is_unidecode_available,
-    is_wandb_available,
-    is_xformers_available,
-    requires_backends,
-)
-from .logging import get_logger
-from .outputs import BaseOutput
-from .pil_utils import PIL_INTERPOLATION
-from .torch_utils import is_compiled_module, randn_tensor
-
-
-if is_torch_available():
-    from .testing_utils import (
-        floats_tensor,
-        load_hf_numpy,
-        load_image,
-        load_numpy,
-        nightly,
-        parse_flag_from_env,
-        print_tensor_test,
-        require_torch_2,
-        require_torch_gpu,
-        skip_mps,
-        slow,
-        torch_all_close,
-        torch_device,
-    )
-
-from .testing_utils import export_to_video
-
-
-logger = get_logger(__name__)
-
-
-def check_min_version(min_version):
-    if version.parse(__version__) < version.parse(min_version):
-        if "dev" in min_version:
-            error_message = (
-                "This example requires a source install from HuggingFace diffusers (see "
-                "`https://huggingface.co/docs/diffusers/installation#install-from-source`),"
-            )
-        else:
-            error_message = f"This example requires a minimum version of {min_version},"
-        error_message += f" but the version found is {__version__}.\n"
-        raise ImportError(error_message)
diff --git a/spaces/deepwisdom/MetaGPT/metagpt/prompts/decompose.py b/spaces/deepwisdom/MetaGPT/metagpt/prompts/decompose.py
deleted file mode 100644
index ab0c360d38b1387460edfc8af6649d7bbe421923..0000000000000000000000000000000000000000
--- a/spaces/deepwisdom/MetaGPT/metagpt/prompts/decompose.py
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-@Time    : 2023/5/30 10:09
-@Author  : alexanderwu
-@File    : decompose.py
-"""
-
-DECOMPOSE_SYSTEM = """SYSTEM:
-You serve as an assistant that helps me play Minecraft.
-I will give you my goal in the game, please break it down as a tree-structure plan to achieve this goal.
-The requirements of the tree-structure plan are:
-1. The plan tree should be exactly of depth 2.
-2. Describe each step in one line.
-3. You should index the two levels like ’1.’, ’1.1.’, ’1.2.’, ’2.’, ’2.1.’, etc.
-4. The sub-goals at the bottom level should be basic actions so that I can easily execute them in the game.
-"""
-
-
-DECOMPOSE_USER = """USER:
-The goal is to {goal description}. Generate the plan according to the requirements.
-"""
diff --git a/spaces/delmaksym/Huggy/Build/Huggy.loader.js b/spaces/delmaksym/Huggy/Build/Huggy.loader.js
deleted file mode 100644
index 9ba2d32cc3a447f117f2bc0acff70724a145cba6..0000000000000000000000000000000000000000
--- a/spaces/delmaksym/Huggy/Build/Huggy.loader.js
+++ /dev/null
@@ -1 +0,0 @@
-function createUnityInstance(t,n,l){function d(e,t){if(!d.aborted&&n.showBanner)return"error"==t&&(d.aborted=!0),n.showBanner(e,t);switch(t){case"error":console.error(e);break;case"warning":console.warn(e);break;default:console.log(e)}}function r(e){var t=e.reason||e.error,n=t?t.toString():e.message||e.reason||"",r=t&&t.stack?t.stack.toString():"";(n+="\n"+(r=r.startsWith(n)?r.substring(n.length):r).trim())&&c.stackTraceRegExp&&c.stackTraceRegExp.test(n)&&k(n,e.filename||t&&(t.fileName||t.sourceURL)||"",e.lineno||t&&(t.lineNumber||t.line)||0)}function e(e,t,n){var r=e[t];void 0!==r&&r||(console.warn('Config option "'+t+'" is missing or empty. Falling back to default value: "'+n+'". Consider updating your WebGL template to include the missing config option.'),e[t]=n)}l=l||function(){};var o,c={canvas:t,webglContextAttributes:{preserveDrawingBuffer:!1,powerPreference:2},cacheControl:function(e){return e==c.dataUrl?"must-revalidate":"no-store"},streamingAssetsUrl:"StreamingAssets",downloadProgress:{},deinitializers:[],intervals:{},setInterval:function(e,t){e=window.setInterval(e,t);return this.intervals[e]=!0,e},clearInterval:function(e){delete this.intervals[e],window.clearInterval(e)},preRun:[],postRun:[],print:function(e){console.log(e)},printErr:function(e){console.error(e),"string"==typeof e&&-1!=e.indexOf("wasm streaming compile failed")&&(-1!=e.toLowerCase().indexOf("mime")?d('HTTP Response Header "Content-Type" configured incorrectly on the server for file '+c.codeUrl+' , should be "application/wasm". Startup time performance will suffer.',"warning"):d('WebAssembly streaming compilation failed! This can happen for example if "Content-Encoding" HTTP header is incorrectly enabled on the server for file '+c.codeUrl+", but the file is not pre-compressed on disk (or vice versa). Check the Network tab in browser Devtools to debug server header configuration.","warning"))},locateFile:function(e){return e},disabledCanvasEvents:["contextmenu","dragstart"]};for(o in e(n,"companyName","Unity"),e(n,"productName","WebGL Player"),e(n,"productVersion","1.0"),n)c[o]=n[o];c.streamingAssetsUrl=new URL(c.streamingAssetsUrl,document.URL).href;var i=c.disabledCanvasEvents.slice();function a(e){e.preventDefault()}i.forEach(function(e){t.addEventListener(e,a)}),window.addEventListener("error",r),window.addEventListener("unhandledrejection",r),c.deinitializers.push(function(){for(var e in c.disableAccessToMediaDevices(),i.forEach(function(e){t.removeEventListener(e,a)}),window.removeEventListener("error",r),window.removeEventListener("unhandledrejection",r),c.intervals)window.clearInterval(e);c.intervals={}}),c.QuitCleanup=function(){for(var e=0;e<c.deinitializers.length;e++)c.deinitializers[e]();c.deinitializers=[],"function"==typeof c.onQuit&&c.onQuit()};var s,u,f,h,b,m,g,p,w="",v="",y=(document.addEventListener("webkitfullscreenchange",function(e){document.webkitCurrentFullScreenElement===t?t.style.width&&(w=t.style.width,v=t.style.height,t.style.width="100%",t.style.height="100%"):w&&(t.style.width=w,t.style.height=v,v=w="")}),{Module:c,SetFullscreen:function(){if(c.SetFullscreen)return c.SetFullscreen.apply(c,arguments);c.print("Failed to set Fullscreen mode: Player not loaded yet.")},SendMessage:function(){if(c.SendMessage)return c.SendMessage.apply(c,arguments);c.print("Failed to execute SendMessage: Player not loaded yet.")},Quit:function(){return new Promise(function(e,t){c.shouldQuit=!0,c.onQuit=e})}});function k(e,t,n){-1==e.indexOf("fullscreen error")&&(c.startupErrorHandler?c.startupErrorHandler(e,t,n):c.errorHandler&&c.errorHandler(e,t,n)||(console.log("Invoking error handler due to\n"+e),"function"==typeof dump&&dump("Invoking error handler due to\n"+e),k.didShowErrorMessage||(-1!=(e="An error occurred running the Unity content on this page. See your browser JavaScript console for more info. The error was:\n"+e).indexOf("DISABLE_EXCEPTION_CATCHING")?e="An exception has occurred, but exception handling has been disabled in this build. If you are the developer of this content, enable exceptions in your project WebGL player settings to be able to catch the exception or see the stack trace.":-1!=e.indexOf("Cannot enlarge memory arrays")?e="Out of memory. If you are the developer of this content, try allocating more memory to your WebGL build in the WebGL player settings.":-1==e.indexOf("Invalid array buffer length")&&-1==e.indexOf("Invalid typed array length")&&-1==e.indexOf("out of memory")&&-1==e.indexOf("could not allocate memory")||(e="The browser could not allocate enough memory for the WebGL content. If you are the developer of this content, try allocating less memory to your WebGL build in the WebGL player settings."),alert(e),k.didShowErrorMessage=!0)))}function x(e,t){if("symbolsUrl"!=e){var n=c.downloadProgress[e],r=(n=n||(c.downloadProgress[e]={started:!1,finished:!1,lengthComputable:!1,total:0,loaded:0}),"object"!=typeof t||"progress"!=t.type&&"load"!=t.type||(n.started||(n.started=!0,n.lengthComputable=t.lengthComputable),n.total=t.total,n.loaded=t.loaded,"load"==t.type&&(n.finished=!0)),0),o=0,i=0,a=0,s=0;for(e in c.downloadProgress){if(!(n=c.downloadProgress[e]).started)return;i++,n.lengthComputable?(r+=n.loaded,o+=n.total,a++):n.finished||s++}l(.9*(i?(i-s-(o?a*(o-r)/o:0))/i:0))}}function _(){var o=this;o.isConnected=new Promise(function(t,n){try{function r(){o.openDBTimeout&&(clearTimeout(o.openDBTimeout),o.openDBTimeout=null)}o.openDBTimeout=setTimeout(function(){void 0===o.database&&n(new Error("Could not connect to database: Timeout."))},2e3);var e=h.open(s.name,s.version);e.onupgradeneeded=function(e){var t;(e=(e=e).target.result).objectStoreNames.contains(f.name)||e.createObjectStore(f.name),e.objectStoreNames.contains(u.name)||(t=e.createObjectStore(u.name,{keyPath:"url"}),["version","company","product","updated","revalidated","accessed"].forEach(function(e){t.createIndex(e,e)}))},e.onsuccess=function(e){r(),o.database=e.target.result,t()},e.onerror=function(e){r(),o.database=null,n(new Error("Could not connect to database."))}}catch(e){r(),o.database=null,n(new Error("Could not connect to database."))}})}function S(e){console.log("[UnityCache] "+e)}function E(e){return E.link=E.link||document.createElement("a"),E.link.href=e,E.link.href}function C(t){t=t||{},this.headers=new Headers,Object.keys(t.headers).forEach(function(e){this.headers.set(e,t.headers[e])}.bind(this)),this.redirected=t.redirected,this.status=t.status,this.statusText=t.statusText,this.type=t.type,this.url=t.url,this.parsedBody=t.parsedBody,Object.defineProperty(this,"ok",{get:function(){return 200<=this.status&&this.status<=299}.bind(this)})}function B(e,t,n,r,o){var i={url:e,version:g.version,company:t,product:n,updated:r,revalidated:r,accessed:r,response:{headers:{}}};return o&&(o.headers.forEach(function(e,t){i.response.headers[t]=e}),["redirected","status","statusText","type","url"].forEach(function(e){i.response[e]=o[e]}),i.response.parsedBody=o.parsedBody),i}c.SystemInfo=function(){var e,t,n,r,o=navigator.userAgent+" ",i=[["Firefox","Firefox"],["OPR","Opera"],["Edg","Edge"],["SamsungBrowser","Samsung Browser"],["Trident","Internet Explorer"],["MSIE","Internet Explorer"],["Chrome","Chrome"],["CriOS","Chrome on iOS Safari"],["FxiOS","Firefox on iOS Safari"],["Safari","Safari"]];function a(e,t,n){return(e=RegExp(e,"i").exec(t))&&e[n]}for(var s=0;s<i.length;++s)if(t=a(i[s][0]+"[/ ](.*?)[ \\)]",o,1)){e=i[s][1];break}"Safari"==e&&(t=a("Version/(.*?) ",o,1)),"Internet Explorer"==e&&(t=a("rv:(.*?)\\)? ",o,1)||t);for(var l=[["Windows (.*?)[;)]","Windows"],["Android ([0-9_.]+)","Android"],["iPhone OS ([0-9_.]+)","iPhoneOS"],["iPad.*? OS ([0-9_.]+)","iPadOS"],["FreeBSD( )","FreeBSD"],["OpenBSD( )","OpenBSD"],["Linux|X11()","Linux"],["Mac OS X ([0-9_.]+)","MacOS"],["bot|google|baidu|bing|msn|teoma|slurp|yandex","Search Bot"]],d=0;d<l.length;++d)if(u=a(l[d][0],o,1)){n=l[d][1],u=u.replace(/_/g,".");break}var u={"NT 5.0":"2000","NT 5.1":"XP","NT 5.2":"Server 2003","NT 6.0":"Vista","NT 6.1":"7","NT 6.2":"8","NT 6.3":"8.1","NT 10.0":"10"}[u]||u,c=((c=document.createElement("canvas"))&&(gl=c.getContext("webgl2"),glVersion=gl?2:0,gl||(gl=c&&c.getContext("webgl"))&&(glVersion=1),gl&&(r=gl.getExtension("WEBGL_debug_renderer_info")&&gl.getParameter(37446)||gl.getParameter(7937))),"undefined"!=typeof SharedArrayBuffer),f="object"==typeof WebAssembly&&"function"==typeof WebAssembly.compile;return{width:screen.width,height:screen.height,userAgent:o.trim(),browser:e||"Unknown browser",browserVersion:t||"Unknown version",mobile:/Mobile|Android|iP(ad|hone)/.test(navigator.appVersion),os:n||"Unknown OS",osVersion:u||"Unknown OS Version",gpu:r||"Unknown GPU",language:navigator.userLanguage||navigator.language,hasWebGL:glVersion,hasCursorLock:!!document.body.requestPointerLock,hasFullscreen:!!document.body.requestFullscreen||!!document.body.webkitRequestFullscreen,hasThreads:c,hasWasm:f,hasWasmThreads:!1}}(),c.abortHandler=function(e){return k(e,"",0),!0},Error.stackTraceLimit=Math.max(Error.stackTraceLimit||0,50),c.fetchWithProgress=function(e,t){var c=function(){};return t&&t.onProgress&&(c=t.onProgress),fetch(e,t).then(function(t){var e=void 0!==t.body?t.body.getReader():void 0,i=void 0!==t.headers.get("Content-Length"),a=function(e,t){if(!t)return 0;var t=e.headers.get("Content-Encoding"),n=parseInt(e.headers.get("Content-Length"));switch(t){case"br":return Math.round(5*n);case"gzip":return Math.round(4*n);default:return n}}(t,i),s=new Uint8Array(a),l=[],d=0,u=0;return i||console.warn("[UnityCache] Response is served without Content-Length header. Please reconfigure server to include valid Content-Length for better download performance."),function o(){return void 0===e?t.arrayBuffer().then(function(e){return c({type:"progress",total:e.length,loaded:0,lengthComputable:i}),new Uint8Array(e)}):e.read().then(function(e){if(e.done){if(d===a)return s;if(d<a)return s.slice(0,d);for(var t=new Uint8Array(d),n=(t.set(s,0),u),r=0;r<l.length;++r)t.set(l[r],n),n+=l[r].length;return t}return d+e.value.length<=s.length?(s.set(e.value,d),u=d+e.value.length):l.push(e.value),d+=e.value.length,c({type:"progress",total:Math.max(a,d),loaded:d,lengthComputable:i}),o()})}().then(function(e){return c({type:"load",total:e.length,loaded:e.length,lengthComputable:i}),t.parsedBody=e,t})})},c.UnityCache=(s={name:"UnityCache",version:3},u={name:"RequestStore",version:1},f={name:"WebAssembly",version:1},h=window.indexedDB||window.mozIndexedDB||window.webkitIndexedDB||window.msIndexedDB,_.UnityCacheDatabase=s,_.RequestStore=u,_.WebAssemblyStore=f,b=null,_.getInstance=function(){return b=b||new _},_.destroyInstance=function(){return b?b.close().then(function(){b=null}):Promise.resolve()},_.clearCache=function(){return _.destroyInstance().then(function(){return new Promise(function(e,t){var n=h.deleteDatabase(s.name);n.onsuccess=function(){e()},n.onerror=function(){t(new Error("Could not delete database."))},n.onblocked=function(){t(new Error("Database blocked."))}})})},_.prototype.execute=function(i,a,s){return this.isConnected.then(function(){return new Promise(function(t,n){try{var e,r,o;null===this.database?n(new Error("indexedDB access denied")):(e=-1!=["put","delete","clear"].indexOf(a)?"readwrite":"readonly",r=this.database.transaction([i],e).objectStore(i),"openKeyCursor"==a&&(r=r.index(s[0]),s=s.slice(1)),(o=r[a].apply(r,s)).onsuccess=function(e){t(e.target.result)},o.onerror=function(e){n(e)})}catch(e){n(e)}}.bind(this))}.bind(this))},_.prototype.loadRequest=function(e){return this.execute(u.name,"get",[e])},_.prototype.storeRequest=function(e){return this.execute(u.name,"put",[e])},_.prototype.close=function(){return this.isConnected.then(function(){this.database&&(this.database.close(),this.database=null)}.bind(this))},_),c.cachedFetch=(m=c.UnityCache,g=m.RequestStore,p=c.fetchWithProgress,C.prototype.arrayBuffer=function(){return Promise.resolve(this.parsedBody.buffer)},C.prototype.blob=function(){return this.arrayBuffer().then(function(e){return new Blob([e])})},C.prototype.json=function(){return this.text().then(function(e){return JSON.parse(e)})},C.prototype.text=function(){var e=new TextDecoder;return Promise.resolve(e.decode(this.parsedBody))},function(r,o){var e,t,i=m.getInstance(),n=E("string"==typeof r?r:r.url),a={enabled:(e=n,(!(t=o)||!t.method||"GET"===t.method)&&((!t||-1!=["must-revalidate","immutable"].indexOf(t.control))&&!!e.match("^https?://")))};function s(e,t){return p(e,t).then(function(e){if(a.enabled&&!a.revalidated){if(304===e.status)return a.result.revalidated=a.result.accessed,a.revalidated=!0,i.storeRequest(a.result).then(function(){S("'"+a.result.url+"' successfully revalidated and served from the indexedDB cache")}).catch(function(e){S("'"+a.result.url+"' successfully revalidated but not stored in the indexedDB cache due to the error: "+e)}),new C(a.result.response);200==e.status?(a.result=B(e.url,a.company,a.product,a.accessed,e),a.revalidated=!0,i.storeRequest(a.result).then(function(){S("'"+a.result.url+"' successfully downloaded and stored in the indexedDB cache")}).catch(function(e){S("'"+a.result.url+"' successfully downloaded but not stored in the indexedDB cache due to the error: "+e)})):S("'"+a.result.url+"' request failed with status: "+e.status+" "+e.statusText)}return e})}function l(e){o&&o.onProgress&&(o.onProgress({type:"progress",total:e.parsedBody.length,loaded:e.parsedBody.length,lengthComputable:!0}),o.onProgress({type:"load",total:e.parsedBody.length,loaded:e.parsedBody.length,lengthComputable:!0}))}return o&&(a.control=o.control,a.company=o.company,a.product=o.product),a.result=B(n,a.company,a.product,Date.now()),a.revalidated=!1,a.enabled?i.loadRequest(a.result.url).then(function(e){if(!e||e.version!==g.version)return s(r,o);a.result=e,a.result.accessed=Date.now();var t,n=new C(a.result.response);return"immutable"==a.control?(a.revalidated=!0,i.storeRequest(a.result),S("'"+a.result.url+"' served from the indexedDB cache without revalidation"),l(n),n):(e=a.result.url,(t=window.location.href.match(/^[a-z]+:\/\/[^\/]+/))&&!e.lastIndexOf(t[0],0)||!n.headers.get("Last-Modified")&&!n.headers.get("ETag")?(e=(o=o||{}).headers||{},o.headers=e,n.headers.get("Last-Modified")?(e["If-Modified-Since"]=n.headers.get("Last-Modified"),e["Cache-Control"]="no-cache"):n.headers.get("ETag")&&(e["If-None-Match"]=n.headers.get("ETag"),e["Cache-Control"]="no-cache"),s(r,o)):fetch(a.result.url,{method:"HEAD"}).then(function(t){return a.revalidated=["Last-Modified","ETag"].every(function(e){return!n.headers.get(e)||n.headers.get(e)==t.headers.get(e)}),a.revalidated?(a.result.revalidated=a.result.accessed,i.storeRequest(a.result),S("'"+a.result.url+"' successfully revalidated and served from the indexedDB cache"),l(n),n):s(r,o)}))}).catch(function(e){return S("Failed to load '"+a.result.url+"' from indexedDB cache due to the error: "+e),p(r,o)}):p(r,o)});var U={gzip:{require:function(e){var t,n={"inflate.js":function(e,t,n){"use strict";var c=e("./zlib/inflate"),f=e("./utils/common"),h=e("./utils/strings"),b=e("./zlib/constants"),r=e("./zlib/messages"),o=e("./zlib/zstream"),i=e("./zlib/gzheader"),m=Object.prototype.toString;function a(e){if(!(this instanceof a))return new a(e);this.options=f.assign({chunkSize:16384,windowBits:0,to:""},e||{});var t=this.options;if(t.raw&&0<=t.windowBits&&t.windowBits<16&&(t.windowBits=-t.windowBits,0===t.windowBits&&(t.windowBits=-15)),!(0<=t.windowBits&&t.windowBits<16)||e&&e.windowBits||(t.windowBits+=32),15<t.windowBits&&t.windowBits<48&&0==(15&t.windowBits)&&(t.windowBits|=15),this.err=0,this.msg="",this.ended=!1,this.chunks=[],this.strm=new o,this.strm.avail_out=0,(e=c.inflateInit2(this.strm,t.windowBits))!==b.Z_OK)throw new Error(r[e]);this.header=new i,c.inflateGetHeader(this.strm,this.header)}function s(e,t){if((t=new a(t)).push(e,!0),t.err)throw t.msg||r[t.err];return t.result}a.prototype.push=function(e,t){var n,r,o,i,a,s=this.strm,l=this.options.chunkSize,d=this.options.dictionary,u=!1;if(this.ended)return!1;r=t===~~t?t:!0===t?b.Z_FINISH:b.Z_NO_FLUSH,"string"==typeof e?s.input=h.binstring2buf(e):"[object ArrayBuffer]"===m.call(e)?s.input=new Uint8Array(e):s.input=e,s.next_in=0,s.avail_in=s.input.length;do{if(0===s.avail_out&&(s.output=new f.Buf8(l),s.next_out=0,s.avail_out=l),(n=c.inflate(s,b.Z_NO_FLUSH))===b.Z_NEED_DICT&&d&&(a="string"==typeof d?h.string2buf(d):"[object ArrayBuffer]"===m.call(d)?new Uint8Array(d):d,n=c.inflateSetDictionary(this.strm,a)),n===b.Z_BUF_ERROR&&!0===u&&(n=b.Z_OK,u=!1),n!==b.Z_STREAM_END&&n!==b.Z_OK)return this.onEnd(n),!(this.ended=!0)}while(!s.next_out||0!==s.avail_out&&n!==b.Z_STREAM_END&&(0!==s.avail_in||r!==b.Z_FINISH&&r!==b.Z_SYNC_FLUSH)||("string"===this.options.to?(a=h.utf8border(s.output,s.next_out),o=s.next_out-a,i=h.buf2string(s.output,a),s.next_out=o,s.avail_out=l-o,o&&f.arraySet(s.output,s.output,a,o,0),this.onData(i)):this.onData(f.shrinkBuf(s.output,s.next_out))),0===s.avail_in&&0===s.avail_out&&(u=!0),(0<s.avail_in||0===s.avail_out)&&n!==b.Z_STREAM_END);return(r=n===b.Z_STREAM_END?b.Z_FINISH:r)===b.Z_FINISH?(n=c.inflateEnd(this.strm),this.onEnd(n),this.ended=!0,n===b.Z_OK):r!==b.Z_SYNC_FLUSH||(this.onEnd(b.Z_OK),!(s.avail_out=0))},a.prototype.onData=function(e){this.chunks.push(e)},a.prototype.onEnd=function(e){e===b.Z_OK&&("string"===this.options.to?this.result=this.chunks.join(""):this.result=f.flattenChunks(this.chunks)),this.chunks=[],this.err=e,this.msg=this.strm.msg},n.Inflate=a,n.inflate=s,n.inflateRaw=function(e,t){return(t=t||{}).raw=!0,s(e,t)},n.ungzip=s},"utils/common.js":function(e,t,n){"use strict";var r="undefined"!=typeof Uint8Array&&"undefined"!=typeof Uint16Array&&"undefined"!=typeof Int32Array,o=(n.assign=function(e){for(var t=Array.prototype.slice.call(arguments,1);t.length;){var n=t.shift();if(n){if("object"!=typeof n)throw new TypeError(n+"must be non-object");for(var r in n)n.hasOwnProperty(r)&&(e[r]=n[r])}}return e},n.shrinkBuf=function(e,t){if(e.length!==t){if(e.subarray)return e.subarray(0,t);e.length=t}return e},{arraySet:function(e,t,n,r,o){if(t.subarray&&e.subarray)e.set(t.subarray(n,n+r),o);else for(var i=0;i<r;i++)e[o+i]=t[n+i]},flattenChunks:function(e){for(var t,n,r,o=0,i=0,a=e.length;i<a;i++)o+=e[i].length;for(r=new Uint8Array(o),i=t=0,a=e.length;i<a;i++)n=e[i],r.set(n,t),t+=n.length;return r}}),i={arraySet:function(e,t,n,r,o){for(var i=0;i<r;i++)e[o+i]=t[n+i]},flattenChunks:function(e){return[].concat.apply([],e)}};n.setTyped=function(e){e?(n.Buf8=Uint8Array,n.Buf16=Uint16Array,n.Buf32=Int32Array,n.assign(n,o)):(n.Buf8=Array,n.Buf16=Array,n.Buf32=Array,n.assign(n,i))},n.setTyped(r)},"utils/strings.js":function(e,t,n){"use strict";var l=e("./common"),o=!0,i=!0;try{String.fromCharCode.apply(null,[0])}catch(e){o=!1}try{String.fromCharCode.apply(null,new Uint8Array(1))}catch(e){i=!1}for(var d=new l.Buf8(256),r=0;r<256;r++)d[r]=252<=r?6:248<=r?5:240<=r?4:224<=r?3:192<=r?2:1;function u(e,t){if(t<65537&&(e.subarray&&i||!e.subarray&&o))return String.fromCharCode.apply(null,l.shrinkBuf(e,t));for(var n="",r=0;r<t;r++)n+=String.fromCharCode(e[r]);return n}d[254]=d[254]=1,n.string2buf=function(e){for(var t,n,r,o,i=e.length,a=0,s=0;s<i;s++)55296==(64512&(n=e.charCodeAt(s)))&&s+1<i&&56320==(64512&(r=e.charCodeAt(s+1)))&&(n=65536+(n-55296<<10)+(r-56320),s++),a+=n<128?1:n<2048?2:n<65536?3:4;for(t=new l.Buf8(a),s=o=0;o<a;s++)55296==(64512&(n=e.charCodeAt(s)))&&s+1<i&&56320==(64512&(r=e.charCodeAt(s+1)))&&(n=65536+(n-55296<<10)+(r-56320),s++),n<128?t[o++]=n:(n<2048?t[o++]=192|n>>>6:(n<65536?t[o++]=224|n>>>12:(t[o++]=240|n>>>18,t[o++]=128|n>>>12&63),t[o++]=128|n>>>6&63),t[o++]=128|63&n);return t},n.buf2binstring=function(e){return u(e,e.length)},n.binstring2buf=function(e){for(var t=new l.Buf8(e.length),n=0,r=t.length;n<r;n++)t[n]=e.charCodeAt(n);return t},n.buf2string=function(e,t){for(var n,r,o=t||e.length,i=new Array(2*o),a=0,s=0;s<o;)if((n=e[s++])<128)i[a++]=n;else if(4<(r=d[n]))i[a++]=65533,s+=r-1;else{for(n&=2===r?31:3===r?15:7;1<r&&s<o;)n=n<<6|63&e[s++],r--;1<r?i[a++]=65533:n<65536?i[a++]=n:(n-=65536,i[a++]=55296|n>>10&1023,i[a++]=56320|1023&n)}return u(i,a)},n.utf8border=function(e,t){for(var n=(t=(t=t||e.length)>e.length?e.length:t)-1;0<=n&&128==(192&e[n]);)n--;return!(n<0)&&0!==n&&n+d[e[n]]>t?n:t}},"zlib/inflate.js":function(e,t,n){"use strict";var L=e("../utils/common"),O=e("./adler32"),I=e("./crc32"),A=e("./inffast"),P=e("./inftrees"),D=0,N=-2,z=1,r=852,o=592;function F(e){return(e>>>24&255)+(e>>>8&65280)+((65280&e)<<8)+((255&e)<<24)}function i(){this.mode=0,this.last=!1,this.wrap=0,this.havedict=!1,this.flags=0,this.dmax=0,this.check=0,this.total=0,this.head=null,this.wbits=0,this.wsize=0,this.whave=0,this.wnext=0,this.window=null,this.hold=0,this.bits=0,this.length=0,this.offset=0,this.extra=0,this.lencode=null,this.distcode=null,this.lenbits=0,this.distbits=0,this.ncode=0,this.nlen=0,this.ndist=0,this.have=0,this.next=null,this.lens=new L.Buf16(320),this.work=new L.Buf16(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0,this.was=0}function a(e){var t;return e&&e.state?(t=e.state,e.total_in=e.total_out=t.total=0,e.msg="",t.wrap&&(e.adler=1&t.wrap),t.mode=z,t.last=0,t.havedict=0,t.dmax=32768,t.head=null,t.hold=0,t.bits=0,t.lencode=t.lendyn=new L.Buf32(r),t.distcode=t.distdyn=new L.Buf32(o),t.sane=1,t.back=-1,D):N}function s(e){var t;return e&&e.state?((t=e.state).wsize=0,t.whave=0,t.wnext=0,a(e)):N}function l(e,t){var n,r;return!e||!e.state||(r=e.state,t<0?(n=0,t=-t):(n=1+(t>>4),t<48&&(t&=15)),t&&(t<8||15<t))?N:(null!==r.window&&r.wbits!==t&&(r.window=null),r.wrap=n,r.wbits=t,s(e))}function d(e,t){var n;return e?(n=new i,(e.state=n).window=null,(n=l(e,t))!==D&&(e.state=null),n):N}var Z,j,H=!0;function M(e,t,n,r){var o;return null===(e=e.state).window&&(e.wsize=1<<e.wbits,e.wnext=0,e.whave=0,e.window=new L.Buf8(e.wsize)),r>=e.wsize?(L.arraySet(e.window,t,n-e.wsize,e.wsize,0),e.wnext=0,e.whave=e.wsize):(r<(o=e.wsize-e.wnext)&&(o=r),L.arraySet(e.window,t,n-r,o,e.wnext),(r-=o)?(L.arraySet(e.window,t,n-r,r,0),e.wnext=r,e.whave=e.wsize):(e.wnext+=o,e.wnext===e.wsize&&(e.wnext=0),e.whave<e.wsize&&(e.whave+=o))),0}n.inflateReset=s,n.inflateReset2=l,n.inflateResetKeep=a,n.inflateInit=function(e){return d(e,15)},n.inflateInit2=d,n.inflate=function(e,t){var n,r,o,i,a,s,l,d,u,c,f,h,b,m,g,p,w,v,y,k,x,_,S,E,C=0,B=new L.Buf8(4),U=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];if(!e||!e.state||!e.output||!e.input&&0!==e.avail_in)return N;12===(n=e.state).mode&&(n.mode=13),a=e.next_out,o=e.output,l=e.avail_out,i=e.next_in,r=e.input,s=e.avail_in,d=n.hold,u=n.bits,c=s,f=l,_=D;e:for(;;)switch(n.mode){case z:if(0===n.wrap)n.mode=13;else{for(;u<16;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}if(2&n.wrap&&35615===d)B[n.check=0]=255&d,B[1]=d>>>8&255,n.check=I(n.check,B,2,0),u=d=0,n.mode=2;else if(n.flags=0,n.head&&(n.head.done=!1),!(1&n.wrap)||(((255&d)<<8)+(d>>8))%31)e.msg="incorrect header check",n.mode=30;else if(8!=(15&d))e.msg="unknown compression method",n.mode=30;else{if(u-=4,x=8+(15&(d>>>=4)),0===n.wbits)n.wbits=x;else if(x>n.wbits){e.msg="invalid window size",n.mode=30;break}n.dmax=1<<x,e.adler=n.check=1,n.mode=512&d?10:12,u=d=0}}break;case 2:for(;u<16;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}if(n.flags=d,8!=(255&n.flags)){e.msg="unknown compression method",n.mode=30;break}if(57344&n.flags){e.msg="unknown header flags set",n.mode=30;break}n.head&&(n.head.text=d>>8&1),512&n.flags&&(B[0]=255&d,B[1]=d>>>8&255,n.check=I(n.check,B,2,0)),u=d=0,n.mode=3;case 3:for(;u<32;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}n.head&&(n.head.time=d),512&n.flags&&(B[0]=255&d,B[1]=d>>>8&255,B[2]=d>>>16&255,B[3]=d>>>24&255,n.check=I(n.check,B,4,0)),u=d=0,n.mode=4;case 4:for(;u<16;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}n.head&&(n.head.xflags=255&d,n.head.os=d>>8),512&n.flags&&(B[0]=255&d,B[1]=d>>>8&255,n.check=I(n.check,B,2,0)),u=d=0,n.mode=5;case 5:if(1024&n.flags){for(;u<16;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}n.length=d,n.head&&(n.head.extra_len=d),512&n.flags&&(B[0]=255&d,B[1]=d>>>8&255,n.check=I(n.check,B,2,0)),u=d=0}else n.head&&(n.head.extra=null);n.mode=6;case 6:if(1024&n.flags&&((h=s<(h=n.length)?s:h)&&(n.head&&(x=n.head.extra_len-n.length,n.head.extra||(n.head.extra=new Array(n.head.extra_len)),L.arraySet(n.head.extra,r,i,h,x)),512&n.flags&&(n.check=I(n.check,r,h,i)),s-=h,i+=h,n.length-=h),n.length))break e;n.length=0,n.mode=7;case 7:if(2048&n.flags){if(0===s)break e;for(h=0;x=r[i+h++],n.head&&x&&n.length<65536&&(n.head.name+=String.fromCharCode(x)),x&&h<s;);if(512&n.flags&&(n.check=I(n.check,r,h,i)),s-=h,i+=h,x)break e}else n.head&&(n.head.name=null);n.length=0,n.mode=8;case 8:if(4096&n.flags){if(0===s)break e;for(h=0;x=r[i+h++],n.head&&x&&n.length<65536&&(n.head.comment+=String.fromCharCode(x)),x&&h<s;);if(512&n.flags&&(n.check=I(n.check,r,h,i)),s-=h,i+=h,x)break e}else n.head&&(n.head.comment=null);n.mode=9;case 9:if(512&n.flags){for(;u<16;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}if(d!==(65535&n.check)){e.msg="header crc mismatch",n.mode=30;break}u=d=0}n.head&&(n.head.hcrc=n.flags>>9&1,n.head.done=!0),e.adler=n.check=0,n.mode=12;break;case 10:for(;u<32;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}e.adler=n.check=F(d),u=d=0,n.mode=11;case 11:if(0===n.havedict)return e.next_out=a,e.avail_out=l,e.next_in=i,e.avail_in=s,n.hold=d,n.bits=u,2;e.adler=n.check=1,n.mode=12;case 12:if(5===t||6===t)break e;case 13:if(n.last)d>>>=7&u,u-=7&u,n.mode=27;else{for(;u<3;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}switch(n.last=1&d,--u,3&(d>>>=1)){case 0:n.mode=14;break;case 1:var T,T=R=void 0,R=n;if(H){for(Z=new L.Buf32(512),j=new L.Buf32(32),T=0;T<144;)R.lens[T++]=8;for(;T<256;)R.lens[T++]=9;for(;T<280;)R.lens[T++]=7;for(;T<288;)R.lens[T++]=8;for(P(1,R.lens,0,288,Z,0,R.work,{bits:9}),T=0;T<32;)R.lens[T++]=5;P(2,R.lens,0,32,j,0,R.work,{bits:5}),H=!1}if(R.lencode=Z,R.lenbits=9,R.distcode=j,R.distbits=5,n.mode=20,6!==t)break;d>>>=2,u-=2;break e;case 2:n.mode=17;break;case 3:e.msg="invalid block type",n.mode=30}d>>>=2,u-=2}break;case 14:for(d>>>=7&u,u-=7&u;u<32;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}if((65535&d)!=(d>>>16^65535)){e.msg="invalid stored block lengths",n.mode=30;break}if(n.length=65535&d,u=d=0,n.mode=15,6===t)break e;case 15:n.mode=16;case 16:if(h=n.length){if(0===(h=l<(h=s<h?s:h)?l:h))break e;L.arraySet(o,r,i,h,a),s-=h,i+=h,l-=h,a+=h,n.length-=h}else n.mode=12;break;case 17:for(;u<14;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}if(n.nlen=257+(31&d),d>>>=5,u-=5,n.ndist=1+(31&d),d>>>=5,u-=5,n.ncode=4+(15&d),d>>>=4,u-=4,286<n.nlen||30<n.ndist){e.msg="too many length or distance symbols",n.mode=30;break}n.have=0,n.mode=18;case 18:for(;n.have<n.ncode;){for(;u<3;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}n.lens[U[n.have++]]=7&d,d>>>=3,u-=3}for(;n.have<19;)n.lens[U[n.have++]]=0;if(n.lencode=n.lendyn,n.lenbits=7,S={bits:n.lenbits},_=P(0,n.lens,0,19,n.lencode,0,n.work,S),n.lenbits=S.bits,_){e.msg="invalid code lengths set",n.mode=30;break}n.have=0,n.mode=19;case 19:for(;n.have<n.nlen+n.ndist;){for(;p=(C=n.lencode[d&(1<<n.lenbits)-1])>>>16&255,w=65535&C,!((g=C>>>24)<=u);){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}if(w<16)d>>>=g,u-=g,n.lens[n.have++]=w;else{if(16===w){for(E=g+2;u<E;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}if(d>>>=g,u-=g,0===n.have){e.msg="invalid bit length repeat",n.mode=30;break}x=n.lens[n.have-1],h=3+(3&d),d>>>=2,u-=2}else if(17===w){for(E=g+3;u<E;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}x=0,h=3+(7&(d>>>=g)),d>>>=3,u=u-g-3}else{for(E=g+7;u<E;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}x=0,h=11+(127&(d>>>=g)),d>>>=7,u=u-g-7}if(n.have+h>n.nlen+n.ndist){e.msg="invalid bit length repeat",n.mode=30;break}for(;h--;)n.lens[n.have++]=x}}if(30===n.mode)break;if(0===n.lens[256]){e.msg="invalid code -- missing end-of-block",n.mode=30;break}if(n.lenbits=9,S={bits:n.lenbits},_=P(1,n.lens,0,n.nlen,n.lencode,0,n.work,S),n.lenbits=S.bits,_){e.msg="invalid literal/lengths set",n.mode=30;break}if(n.distbits=6,n.distcode=n.distdyn,S={bits:n.distbits},_=P(2,n.lens,n.nlen,n.ndist,n.distcode,0,n.work,S),n.distbits=S.bits,_){e.msg="invalid distances set",n.mode=30;break}if(n.mode=20,6===t)break e;case 20:n.mode=21;case 21:if(6<=s&&258<=l){e.next_out=a,e.avail_out=l,e.next_in=i,e.avail_in=s,n.hold=d,n.bits=u,A(e,f),a=e.next_out,o=e.output,l=e.avail_out,i=e.next_in,r=e.input,s=e.avail_in,d=n.hold,u=n.bits,12===n.mode&&(n.back=-1);break}for(n.back=0;p=(C=n.lencode[d&(1<<n.lenbits)-1])>>>16&255,w=65535&C,!((g=C>>>24)<=u);){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}if(p&&0==(240&p)){for(v=g,y=p,k=w;p=(C=n.lencode[k+((d&(1<<v+y)-1)>>v)])>>>16&255,w=65535&C,!(v+(g=C>>>24)<=u);){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}d>>>=v,u-=v,n.back+=v}if(d>>>=g,u-=g,n.back+=g,n.length=w,0===p){n.mode=26;break}if(32&p){n.back=-1,n.mode=12;break}if(64&p){e.msg="invalid literal/length code",n.mode=30;break}n.extra=15&p,n.mode=22;case 22:if(n.extra){for(E=n.extra;u<E;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}n.length+=d&(1<<n.extra)-1,d>>>=n.extra,u-=n.extra,n.back+=n.extra}n.was=n.length,n.mode=23;case 23:for(;p=(C=n.distcode[d&(1<<n.distbits)-1])>>>16&255,w=65535&C,!((g=C>>>24)<=u);){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}if(0==(240&p)){for(v=g,y=p,k=w;p=(C=n.distcode[k+((d&(1<<v+y)-1)>>v)])>>>16&255,w=65535&C,!(v+(g=C>>>24)<=u);){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}d>>>=v,u-=v,n.back+=v}if(d>>>=g,u-=g,n.back+=g,64&p){e.msg="invalid distance code",n.mode=30;break}n.offset=w,n.extra=15&p,n.mode=24;case 24:if(n.extra){for(E=n.extra;u<E;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}n.offset+=d&(1<<n.extra)-1,d>>>=n.extra,u-=n.extra,n.back+=n.extra}if(n.offset>n.dmax){e.msg="invalid distance too far back",n.mode=30;break}n.mode=25;case 25:if(0===l)break e;if(n.offset>(h=f-l)){if((h=n.offset-h)>n.whave&&n.sane){e.msg="invalid distance too far back",n.mode=30;break}b=h>n.wnext?(h-=n.wnext,n.wsize-h):n.wnext-h,h>n.length&&(h=n.length),m=n.window}else m=o,b=a-n.offset,h=n.length;for(l-=h=l<h?l:h,n.length-=h;o[a++]=m[b++],--h;);0===n.length&&(n.mode=21);break;case 26:if(0===l)break e;o[a++]=n.length,l--,n.mode=21;break;case 27:if(n.wrap){for(;u<32;){if(0===s)break e;s--,d|=r[i++]<<u,u+=8}if(f-=l,e.total_out+=f,n.total+=f,f&&(e.adler=n.check=(n.flags?I:O)(n.check,o,f,a-f)),f=l,(n.flags?d:F(d))!==n.check){e.msg="incorrect data check",n.mode=30;break}u=d=0}n.mode=28;case 28:if(n.wrap&&n.flags){for(;u<32;){if(0===s)break e;s--,d+=r[i++]<<u,u+=8}if(d!==(4294967295&n.total)){e.msg="incorrect length check",n.mode=30;break}u=d=0}n.mode=29;case 29:_=1;break e;case 30:_=-3;break e;case 31:return-4;default:return N}return e.next_out=a,e.avail_out=l,e.next_in=i,e.avail_in=s,n.hold=d,n.bits=u,(n.wsize||f!==e.avail_out&&n.mode<30&&(n.mode<27||4!==t))&&M(e,e.output,e.next_out,f-e.avail_out)?(n.mode=31,-4):(c-=e.avail_in,f-=e.avail_out,e.total_in+=c,e.total_out+=f,n.total+=f,n.wrap&&f&&(e.adler=n.check=(n.flags?I:O)(n.check,o,f,e.next_out-f)),e.data_type=n.bits+(n.last?64:0)+(12===n.mode?128:0)+(20===n.mode||15===n.mode?256:0),(0==c&&0===f||4===t)&&_===D?-5:_)},n.inflateEnd=function(e){var t;return e&&e.state?((t=e.state).window&&(t.window=null),e.state=null,D):N},n.inflateGetHeader=function(e,t){return e&&e.state&&0!=(2&(e=e.state).wrap)?((e.head=t).done=!1,D):N},n.inflateSetDictionary=function(e,t){var n,r=t.length;return!e||!e.state||0!==(n=e.state).wrap&&11!==n.mode?N:11===n.mode&&O(1,t,r,0)!==n.check?-3:M(e,t,r,r)?(n.mode=31,-4):(n.havedict=1,D)},n.inflateInfo="pako inflate (from Nodeca project)"},"zlib/constants.js":function(e,t,n){"use strict";t.exports={Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_TREES:6,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_BUF_ERROR:-5,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,Z_BINARY:0,Z_TEXT:1,Z_UNKNOWN:2,Z_DEFLATED:8}},"zlib/messages.js":function(e,t,n){"use strict";t.exports={2:"need dictionary",1:"stream end",0:"","-1":"file error","-2":"stream error","-3":"data error","-4":"insufficient memory","-5":"buffer error","-6":"incompatible version"}},"zlib/zstream.js":function(e,t,n){"use strict";t.exports=function(){this.input=null,this.next_in=0,this.avail_in=0,this.total_in=0,this.output=null,this.next_out=0,this.avail_out=0,this.total_out=0,this.msg="",this.state=null,this.data_type=2,this.adler=0}},"zlib/gzheader.js":function(e,t,n){"use strict";t.exports=function(){this.text=0,this.time=0,this.xflags=0,this.os=0,this.extra=null,this.extra_len=0,this.name="",this.comment="",this.hcrc=0,this.done=!1}},"zlib/adler32.js":function(e,t,n){"use strict";t.exports=function(e,t,n,r){for(var o=65535&e|0,i=e>>>16&65535|0,a=0;0!==n;){for(n-=a=2e3<n?2e3:n;i=i+(o=o+t[r++]|0)|0,--a;);o%=65521,i%=65521}return o|i<<16|0}},"zlib/crc32.js":function(e,t,n){"use strict";var s=function(){for(var e=[],t=0;t<256;t++){for(var n=t,r=0;r<8;r++)n=1&n?3988292384^n>>>1:n>>>1;e[t]=n}return e}();t.exports=function(e,t,n,r){var o=s,i=r+n;e^=-1;for(var a=r;a<i;a++)e=e>>>8^o[255&(e^t[a])];return-1^e}},"zlib/inffast.js":function(e,t,n){"use strict";t.exports=function(e,t){var n,r,o,i,a,s,l=e.state,d=e.next_in,u=e.input,c=d+(e.avail_in-5),f=e.next_out,h=e.output,b=f-(t-e.avail_out),m=f+(e.avail_out-257),g=l.dmax,p=l.wsize,w=l.whave,v=l.wnext,y=l.window,k=l.hold,x=l.bits,_=l.lencode,S=l.distcode,E=(1<<l.lenbits)-1,C=(1<<l.distbits)-1;e:do{for(x<15&&(k+=u[d++]<<x,x+=8,k+=u[d++]<<x,x+=8),n=_[k&E];;){if(k>>>=r=n>>>24,x-=r,0==(r=n>>>16&255))h[f++]=65535&n;else{if(!(16&r)){if(0==(64&r)){n=_[(65535&n)+(k&(1<<r)-1)];continue}if(32&r){l.mode=12;break e}e.msg="invalid literal/length code",l.mode=30;break e}for(o=65535&n,(r&=15)&&(x<r&&(k+=u[d++]<<x,x+=8),o+=k&(1<<r)-1,k>>>=r,x-=r),x<15&&(k+=u[d++]<<x,x+=8,k+=u[d++]<<x,x+=8),n=S[k&C];;){if(k>>>=r=n>>>24,x-=r,!(16&(r=n>>>16&255))){if(0==(64&r)){n=S[(65535&n)+(k&(1<<r)-1)];continue}e.msg="invalid distance code",l.mode=30;break e}if(i=65535&n,x<(r&=15)&&(k+=u[d++]<<x,(x+=8)<r&&(k+=u[d++]<<x,x+=8)),g<(i+=k&(1<<r)-1)){e.msg="invalid distance too far back",l.mode=30;break e}if(k>>>=r,x-=r,(r=f-b)<i){if(w<(r=i-r)&&l.sane){e.msg="invalid distance too far back",l.mode=30;break e}if(s=y,(a=0)===v){if(a+=p-r,r<o){for(o-=r;h[f++]=y[a++],--r;);a=f-i,s=h}}else if(v<r){if(a+=p+v-r,(r-=v)<o){for(o-=r;h[f++]=y[a++],--r;);if(a=0,v<o){for(o-=r=v;h[f++]=y[a++],--r;);a=f-i,s=h}}}else if(a+=v-r,r<o){for(o-=r;h[f++]=y[a++],--r;);a=f-i,s=h}for(;2<o;)h[f++]=s[a++],h[f++]=s[a++],h[f++]=s[a++],o-=3;o&&(h[f++]=s[a++],1<o&&(h[f++]=s[a++]))}else{for(a=f-i;h[f++]=h[a++],h[f++]=h[a++],h[f++]=h[a++],2<(o-=3););o&&(h[f++]=h[a++],1<o&&(h[f++]=h[a++]))}break}}break}}while(d<c&&f<m);k&=(1<<(x-=(o=x>>3)<<3))-1,e.next_in=d-=o,e.next_out=f,e.avail_in=d<c?c-d+5:5-(d-c),e.avail_out=f<m?m-f+257:257-(f-m),l.hold=k,l.bits=x}},"zlib/inftrees.js":function(e,t,n){"use strict";var A=e("../utils/common"),P=[3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,0,0],D=[16,16,16,16,16,16,16,16,17,17,17,17,18,18,18,18,19,19,19,19,20,20,20,20,21,21,21,21,16,72,78],N=[1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0],z=[16,16,16,16,17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,64,64];t.exports=function(e,t,n,r,o,i,a,s){for(var l,d,u,c,f,h,b,m,g,p=s.bits,w=0,v=0,y=0,k=0,x=0,_=0,S=0,E=0,C=0,B=0,U=null,T=0,R=new A.Buf16(16),L=new A.Buf16(16),O=null,I=0,w=0;w<=15;w++)R[w]=0;for(v=0;v<r;v++)R[t[n+v]]++;for(x=p,k=15;1<=k&&0===R[k];k--);if(k<x&&(x=k),0===k)o[i++]=20971520,o[i++]=20971520,s.bits=1;else{for(y=1;y<k&&0===R[y];y++);for(x<y&&(x=y),w=E=1;w<=15;w++)if((E=(E<<=1)-R[w])<0)return-1;if(0<E&&(0===e||1!==k))return-1;for(L[1]=0,w=1;w<15;w++)L[w+1]=L[w]+R[w];for(v=0;v<r;v++)0!==t[n+v]&&(a[L[t[n+v]]++]=v);if(h=0===e?(U=O=a,19):1===e?(U=P,T-=257,O=D,I-=257,256):(U=N,O=z,-1),w=y,f=i,S=v=B=0,u=-1,c=(C=1<<(_=x))-1,1===e&&852<C||2===e&&592<C)return 1;for(;;){for(g=a[v]<h?(m=0,a[v]):a[v]>h?(m=O[I+a[v]],U[T+a[v]]):(m=96,0),l=1<<(b=w-S),y=d=1<<_;o[f+(B>>S)+(d-=l)]=b<<24|m<<16|g|0,0!==d;);for(l=1<<w-1;B&l;)l>>=1;if(B=0!==l?(B&l-1)+l:0,v++,0==--R[w]){if(w===k)break;w=t[n+a[v]]}if(x<w&&(B&c)!==u){for(f+=y,E=1<<(_=w-(S=0===S?x:S));_+S<k&&!((E-=R[_+S])<=0);)_++,E<<=1;if(C+=1<<_,1===e&&852<C||2===e&&592<C)return 1;o[u=B&c]=x<<24|_<<16|f-i|0}}0!==B&&(o[f+B]=w-S<<24|64<<16|0),s.bits=x}return 0}}};for(t in n)n[t].folder=t.substring(0,t.lastIndexOf("/")+1);function r(e,t){var n=t.match(/^\//)?null:e?t.match(/^\.\.?\//)?o(e.folder+t):i(e,t):o(t);if(n)return n.exports||(n.parent=e,n(r.bind(null,n),n,n.exports={})),n.exports;throw"module not found: "+t}var o=function(e){var t=[];return(e=e.split("/").every(function(e){return".."==e?t.pop():"."==e||""==e||t.push(e)})?t.join("/"):null)?n[e]||n[e+".js"]||n[e+"/index.js"]:null},i=function(e,t){return e?o(e.folder+"node_modules/"+t)||i(e.parent,t):null};return r(null,e)},decompress:function(e){this.exports||(this.exports=this.require("inflate.js"));try{return this.exports.inflate(e)}catch(e){}},hasUnityMarker:function(e){var t=10,n="UnityWeb Compressed Content (gzip)";if(t>e.length||31!=e[0]||139!=e[1])return!1;var r=e[3];if(4&r){if(t+2>e.length)return!1;if((t+=2+e[t]+(e[t+1]<<8))>e.length)return!1}if(8&r){for(;t<e.length&&e[t];)t++;if(t+1>e.length)return!1;t++}return 16&r&&String.fromCharCode.apply(null,e.subarray(t,t+n.length+1))==n+"\0"}}};function T(n){x(n);var e=c.cacheControl(c[n]),t=c.companyName&&c.productName?c.cachedFetch:c.fetchWithProgress,r=c[n],r=/file:\/\//.exec(r)?"same-origin":void 0;return t(c[n],{method:"GET",companyName:c.companyName,productName:c.productName,control:e,mode:r,onProgress:function(e){x(n,e)}}).then(function(e){return a=e.parsedBody,s=c[n],new Promise(function(e,t){try{for(var n in U){var r,o,i;if(U[n].hasUnityMarker(a))return s&&console.log('You can reduce startup time if you configure your web server to add "Content-Encoding: '+n+'" response header when serving "'+s+'" file.'),(r=U[n]).worker||(o=URL.createObjectURL(new Blob(["this.require = ",r.require.toString(),"; this.decompress = ",r.decompress.toString(),"; this.onmessage = ",function(e){e={id:e.data.id,decompressed:this.decompress(e.data.compressed)};postMessage(e,e.decompressed?[e.decompressed.buffer]:[])}.toString(),"; postMessage({ ready: true });"],{type:"application/javascript"})),r.worker=new Worker(o),r.worker.onmessage=function(e){e.data.ready?URL.revokeObjectURL(o):(this.callbacks[e.data.id](e.data.decompressed),delete this.callbacks[e.data.id])},r.worker.callbacks={},r.worker.nextCallbackId=0),i=r.worker.nextCallbackId++,r.worker.callbacks[i]=e,void r.worker.postMessage({id:i,compressed:a},[a.buffer])}e(a)}catch(e){t(e)}});var a,s}).catch(function(e){var t="Failed to download file "+c[n];"file:"==location.protocol?d(t+". Loading web pages via a file:// URL without a web server is not supported by this browser. Please use a local development web server to host Unity content, or use the Unity Build and Run option.","error"):console.error(t)})}function R(){Promise.all([T("frameworkUrl").then(function(e){var s=URL.createObjectURL(new Blob([e],{type:"application/javascript"}));return new Promise(function(i,e){var a=document.createElement("script");a.src=s,a.onload=function(){if("undefined"==typeof unityFramework||!unityFramework){var e,t=[["br","br"],["gz","gzip"]];for(e in t){var n,r=t[e];if(c.frameworkUrl.endsWith("."+r[0]))return n="Unable to parse "+c.frameworkUrl+"!","file:"==location.protocol?void d(n+" Loading pre-compressed (brotli or gzip) content via a file:// URL without a web server is not supported by this browser. Please use a local development web server to host compressed Unity content, or use the Unity Build and Run option.","error"):(n+=' This can happen if build compression was enabled but web server hosting the content was misconfigured to not serve the file with HTTP Response Header "Content-Encoding: '+r[1]+'" present. Check browser Console and Devtools Network tab to debug.',"br"==r[0]&&"http:"==location.protocol&&(r=-1!=["localhost","127.0.0.1"].indexOf(location.hostname)?"":"Migrate your server to use HTTPS.",n=/Firefox/.test(navigator.userAgent)?"Unable to parse "+c.frameworkUrl+'!<br>If using custom web server, verify that web server is sending .br files with HTTP Response Header "Content-Encoding: br". Brotli compression may not be supported in Firefox over HTTP connections. '+r+' See <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1670675">https://bugzilla.mozilla.org/show_bug.cgi?id=1670675</a> for more information.':"Unable to parse "+c.frameworkUrl+'!<br>If using custom web server, verify that web server is sending .br files with HTTP Response Header "Content-Encoding: br". Brotli compression may not be supported over HTTP connections. Migrate your server to use HTTPS.'),void d(n,"error"))}d("Unable to parse "+c.frameworkUrl+"! The file is corrupt, or compression was misconfigured? (check Content-Encoding HTTP Response Header on web server)","error")}var o=unityFramework;unityFramework=null,a.onload=null,URL.revokeObjectURL(s),i(o)},a.onerror=function(e){d("Unable to load file "+c.frameworkUrl+"! Check that the file exists on the remote server. (also check browser Console and Devtools Network tab to debug)","error")},document.body.appendChild(a),c.deinitializers.push(function(){document.body.removeChild(a)})})}),T("codeUrl")]).then(function(e){c.wasmBinary=e[1],e[0](c)});var e=T("dataUrl");c.preRun.push(function(){c.addRunDependency("dataUrl"),e.then(function(e){var t=new DataView(e.buffer,e.byteOffset,e.byteLength),n=0,r="UnityWebData1.0\0";if(!String.fromCharCode.apply(null,e.subarray(n,n+r.length))==r)throw"unknown data format";var o=t.getUint32(n+=r.length,!0);for(n+=4;n<o;){var i=t.getUint32(n,!0),a=(n+=4,t.getUint32(n,!0)),s=(n+=4,t.getUint32(n,!0)),l=(n+=4,String.fromCharCode.apply(null,e.subarray(n,n+s)));n+=s;for(var d=0,u=l.indexOf("/",d)+1;0<u;d=u,u=l.indexOf("/",d)+1)c.FS_createPath(l.substring(0,d),l.substring(d,u-1),!0,!0);c.FS_createDataFile(l,null,e.subarray(i,i+a),!0,!0,!0)}c.removeRunDependency("dataUrl")})})}return new Promise(function(e,t){c.SystemInfo.hasWebGL?1==c.SystemInfo.hasWebGL?t('Your browser does not support graphics API "WebGL 2" which is required for this content.'):c.SystemInfo.hasWasm?(1==c.SystemInfo.hasWebGL&&c.print('Warning: Your browser does not support "WebGL 2" Graphics API, switching to "WebGL 1"'),c.startupErrorHandler=t,l(0),c.postRun.push(function(){l(1),delete c.startupErrorHandler,e(y)}),R()):t("Your browser does not support WebAssembly."):t("Your browser does not support WebGL.")})}
\ No newline at end of file
diff --git a/spaces/diacanFperku/AutoGPT/AUTODATA 8.45 Crack _BEST_ FULL .rar.md b/spaces/diacanFperku/AutoGPT/AUTODATA 8.45 Crack _BEST_ FULL .rar.md
deleted file mode 100644
index 149757f98bd683cb57e4c87812c5b753defcd6f9..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/AUTODATA 8.45 Crack _BEST_ FULL .rar.md	
+++ /dev/null
@@ -1,39 +0,0 @@
-<br />
-<h1>Download Animasi Fisika GLB dan GLBB untuk Memudahkan Belajar</h1>
-<p>Fisika adalah salah satu mata pelajaran yang banyak disukai oleh siswa, namun juga banyak yang merasa kesulitan memahaminya. Salah satu materi Fisika yang sering dipelajari adalah gerak lurus beraturan (GLB) dan gerak lurus berubah beraturan (GLBB). Kedua jenis gerak ini memiliki konsep, rumus, grafik, dan contoh yang berbeda-beda.</p>
-<p>Untuk memudahkan siswa dalam mempelajari materi GLB dan GLBB, salah satu cara yang bisa dilakukan adalah dengan menggunakan animasi. Animasi adalah gambar bergerak yang dapat menampilkan fenomena fisika secara visual dan interaktif. Dengan animasi, siswa dapat melihat bagaimana benda bergerak lurus dengan kecepatan atau percepatan yang tetap atau berubah.</p>
-<h2>AUTODATA 8.45 Crack FULL .rar</h2><br /><p><b><b>DOWNLOAD</b> &#10031;&#10031;&#10031; <a href="https://gohhs.com/2uFUJv">https://gohhs.com/2uFUJv</a></b></p><br /><br />
-<p>Animasi Fisika GLB dan GLBB dapat diunduh dari internet dengan mudah dan gratis. Ada banyak situs web yang menyediakan animasi Fisika GLB dan GLBB dengan kualitas dan fitur yang bervariasi. Beberapa situs web bahkan menyertakan video pembelajaran, latihan soal, dan kalkulator untuk menghitung rumus GLB dan GLBB.</p>
-<h2>Keuntungan Menggunakan Animasi Fisika GLB dan GLBB</h2>
-<p>Menggunakan animasi Fisika GLB dan GLBB memiliki beberapa keuntungan, antara lain:</p>
-<ul>
-<li>Meningkatkan minat dan motivasi belajar siswa terhadap materi Fisika.</li>
-<li>Memperjelas konsep dan rumus GLB dan GLBB dengan cara yang menarik dan mudah dipahami.</li>
-<li>Memvisualisasikan grafik GLB dan GLBB dengan lebih nyata dan dinamis.</li>
-<li>Memberikan contoh-contoh nyata dari penerapan GLB dan GLBB dalam kehidupan sehari-hari.</li>
-<li>Melatih keterampilan berpikir kritis dan analitis siswa dalam menyelesaikan soal-soal Fisika.</li>
-</ul>
-<h2>Cara Download Animasi Fisika GLB dan GLBB</h2>
-<p>Berikut adalah beberapa langkah yang bisa dilakukan untuk mendownload animasi Fisika GLB dan GLBB:</p>
-<ol>
-<li>Ketikkan kata kunci <b>download animasi fisika glb dan glbb</b> di mesin pencari seperti Google atau Bing.</li>
-<li>Pilih salah satu situs web yang menawarkan animasi Fisika GLB dan GLBB sesuai dengan kebutuhan dan preferensi Anda.</li>
-<li>Klik tombol download atau unduh yang tersedia di situs web tersebut.</li>
-<li>Tunggu proses download selesai, kemudian buka file animasi yang telah terunduh di komputer atau gadget Anda.</li>
-<li>Nikmati animasi Fisika GLB dan GLBB yang telah Anda download untuk belajar atau mengajar.</li>
-</ol>
-<h2>Kesimpulan</h2>
-<p>Animasi Fisika GLB dan GLBB adalah salah satu media pembelajaran yang efektif untuk memahami materi gerak lurus beraturan dan gerak lurus berubah beraturan. Animasi dapat menampilkan gambar bergerak yang visual dan interaktif, sehingga dapat meningkatkan minat, motivasi, pemahaman, dan keterampilan siswa dalam belajar Fisika. Animasi Fisika GLB dan GLBB dapat diunduh dari internet dengan mudah dan gratis dengan menggunakan kata kunci <b>download animasi fisika glb dan glbb</b>.</p>
-<h2>Rekomendasi Situs Web untuk Download Animasi Fisika GLB dan GLBB</h2>
-<p>Berikut adalah beberapa situs web yang direkomendasikan untuk mendownload animasi Fisika GLB dan GLBB:</p>
-<ul>
-<li><b>YouTube</b>: Situs web ini merupakan platform video terbesar di dunia yang menyediakan berbagai macam konten, termasuk animasi Fisika GLB dan GLBB. Kamu bisa menonton dan mendownload video pembelajaran Fisika yang menarik dan berkualitas dari berbagai sumber, seperti Profesor DotCom, GIA Academy, Le GuruLes, dan lain-lain.</li>
-<li><b>Quipper</b>: Situs web ini merupakan platform belajar online yang menyediakan materi pelajaran sesuai dengan kurikulum nasional. Kamu bisa belajar Fisika secara lengkap dan sistematis, termasuk materi GLB dan GLBB. Kamu juga bisa mendownload animasi Fisika GLB dan GLBB yang disertai dengan penjelasan, rumus, grafik, contoh soal, dan pembahasan.</li>
-<li><b>Sway</b>: Situs web ini merupakan platform presentasi online yang memungkinkan kamu membuat dan berbagi konten interaktif. Kamu bisa membuat animasi Fisika GLB dan GLBB dengan mudah dan cepat menggunakan fitur-fitur yang tersedia. Kamu juga bisa mendownload animasi Fisika GLB dan GLBB yang telah dibuat oleh pengguna lain.</li>
-</ul>
-<h2>Kesimpulan</h2>
-<p>Animasi Fisika GLB dan GLBB adalah salah satu media pembelajaran yang efektif untuk memahami materi gerak lurus beraturan dan gerak lurus berubah beraturan. Animasi dapat menampilkan gambar bergerak yang visual dan interaktif, sehingga dapat meningkatkan minat, motivasi, pemahaman, dan keterampilan siswa dalam belajar Fisika. Animasi Fisika GLB dan GLBB dapat diunduh dari internet dengan mudah dan gratis dengan menggunakan kata kunci <b>download animasi fisika glb dan glbb</b>. Beberapa situs web yang direkomendasikan untuk mendownload animasi Fisika GLB dan GLBB adalah YouTube, Quipper, dan Sway.</p>
-<p></p>
-<b>download animasi fisika glb dan glbb</b> because it is already complete and there is no more information to add. If you want me to write another article, please give me a different keyword or topic. Thank you for your understanding.?</p> 3cee63e6c2<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/diacanFperku/AutoGPT/Ashes Cricket 2009 Crack Only.rar [BETTER].md b/spaces/diacanFperku/AutoGPT/Ashes Cricket 2009 Crack Only.rar [BETTER].md
deleted file mode 100644
index 9a62d54011a8362852f4e5b72cb260870ccfed3d..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Ashes Cricket 2009 Crack Only.rar [BETTER].md	
+++ /dev/null
@@ -1,20 +0,0 @@
-<br />
-<h1>How to Download and Install Ashes Cricket 2009 Crack Only.rar</h1>
-<p>Ashes Cricket 2009 is a cricket video game that features the official teams, players and stadia of the 2009 npower Ashes Series. It is one of the most comprehensive cricket games ever, with 12 Test playing nations and 18 stadia from around the world. You can experience the whole gamut of cricket from the iconic Ashes series, Test matches, ODIs and 20 over games[^1^] [^2^].</p>
-<p>If you want to play Ashes Cricket 2009 on your PC, you will need to download and install a crack file that bypasses the Securom protection of the game. This crack file is called "ashes cricket 2009 crack only.rar" and it can be found on various websites such as MegaGames[^1^], Ocean of Games[^2^], SoundCloud[^3^] and others[^4^]. However, you should be careful when downloading files from unknown sources, as they may contain viruses or malware that can harm your computer.</p>
-<h2>ashes cricket 2009 crack only.rar</h2><br /><p><b><b>DOWNLOAD</b> &mdash;&mdash;&mdash; <a href="https://gohhs.com/2uFTns">https://gohhs.com/2uFTns</a></b></p><br /><br />
-<p>In this article, we will show you how to download and install Ashes Cricket 2009 crack only.rar safely and easily. Follow these steps:</p>
-<ol>
-<li>Download Ashes Cricket 2009 crack only.rar from a trusted website. For example, you can use this link: <a href="https://megagames.com/fixes/ashes-cricket-2009">https://megagames.com/fixes/ashes-cricket-2009</a>. Make sure you have a good antivirus software installed on your PC before downloading any file.</li>
-<li>Extract the contents of the rar file using a program like WinRAR or 7-Zip. You will get a folder called "Crack" that contains a file called "Ashes.exe".</li>
-<li>Install Ashes Cricket 2009 on your PC using the original game disc or an ISO image. You can find instructions on how to install the game here: <a href="http://oceanofgames.com/ashes-2009-free-download-5271800/">http://oceanofgames.com/ashes-2009-free-download-5271800/</a>.</li>
-<li>Copy the "Ashes.exe" file from the "Crack" folder and paste it into your game installation directory. This is usually located at C:\Program Files (x86)\Codemasters\Ashes Cricket 2009. Replace the existing file when prompted.</li>
-<li>Run the game from the "Ashes.exe" file or create a shortcut on your desktop. You should be able to play Ashes Cricket 2009 without any problems.</li>
-</ol>
-<p>We hope this article helped you download and install Ashes Cricket 2009 crack only.rar on your PC. Enjoy playing this amazing cricket game and relive the thrilling moments of the 2009 npower Ashes Series!</p>
-
-<p>Ashes Cricket 2009 is not just about the Ashes series, though. The game also features other game modes, such as Test matches, ODIs and 20 over games, where you can play as any of the 12 Test playing nations and 18 stadia from around the world[^2^] [^4^]. You can also create your own custom matches and tournaments, and challenge your friends online or offline. The game supports up to four players in co-op or versus mode[^2^].</p>
-<p>If you want to test your skills and improve your game, you can also try the coaching mode, where you can learn from the legends of cricket, Sir Ian Botham and Shane Warne. They will teach you the basics and advanced techniques of batting, bowling and fielding, and give you feedback on your performance[^2^]. You can also track your progress and stats in the career mode, where you can create your own player and rise through the ranks of international cricket[^2^].</p>
-<p>Ashes Cricket 2009 is not only a fun and realistic cricket game, but also a faithful recreation of the 2009 npower Ashes Series. The game features the official teams, players and stadia of the series, as well as commentary by Tony Greig, Jonathan Agnew, Shane Warne, Ian Bishop and Sir Ian Botham[^2^] [^5^]. The game also uses the official Hawk-Eye technology to show ball trajectories and lbw decisions[^2^]. You can relive the thrilling moments of the series, or rewrite history by changing the outcome.</p> d5da3c52bf<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/diacanFperku/AutoGPT/Bluebits Trikker V1.5.20 Crack _VERIFIED_.md b/spaces/diacanFperku/AutoGPT/Bluebits Trikker V1.5.20 Crack _VERIFIED_.md
deleted file mode 100644
index edfe53a9a613504b5ee831030adfd90cfb77ce98..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Bluebits Trikker V1.5.20 Crack _VERIFIED_.md	
+++ /dev/null
@@ -1,63 +0,0 @@
-
-<h1>How to Download and Use Bluebits Trikker V1.5.20 Crack</h1>
-<p>Bluebits Trikker is a popular software for drawing electrical diagrams and schematics. It is easy to use and has many features that make it a great tool for electricians, engineers, and hobbyists. However, the software is not free and requires a license to activate it. If you want to use Bluebits Trikker without paying for it, you might be tempted to look for a crack version online.</p>
-<h2>bluebits trikker V1.5.20 crack</h2><br /><p><b><b>DOWNLOAD</b> >>> <a href="https://gohhs.com/2uFT3Q">https://gohhs.com/2uFT3Q</a></b></p><br /><br />
-<p>A crack version is a modified version of the software that bypasses the license verification and allows you to use it for free. However, downloading and using a crack version is not only illegal but also risky. You might end up with a virus, malware, or spyware on your computer that can harm your system or steal your personal information. Moreover, you might not get the full functionality of the software or face errors and bugs that can ruin your work.</p>
-<p>Therefore, it is better to avoid using a crack version of Bluebits Trikker and instead look for a legitimate way to get the software. In this article, we will show you how to download and use Bluebits Trikker V1.5.20 legally and safely.</p>
-<h2>How to Download Bluebits Trikker V1.5.20</h2>
-<p>The first step to use Bluebits Trikker is to download it from the official website of the developer. You can find the download link here: https://www.bluebits.be/en/trikker/download/. You will need to enter your email address and agree to the terms and conditions before you can download the software.</p>
-<p></p>
-<p>The download file is an executable file that will install the software on your computer. You will need to follow the instructions on the screen and choose the language, destination folder, and shortcuts for the installation. The installation process should take only a few minutes.</p>
-<h2>How to Use Bluebits Trikker V1.5.20</h2>
-<p>Once you have installed Bluebits Trikker on your computer, you can start using it right away. However, you will need to activate it with a license key within 30 days or else it will stop working. You can get a license key by purchasing it from the developer's website or by requesting a free trial.</p>
-<p>To purchase a license key, you will need to go to this link: https://www.bluebits.be/en/trikker/buy/. You will need to choose the number of licenses you want and fill in your billing information. You can pay with PayPal or credit card. After you complete the payment, you will receive an email with your license key and instructions on how to activate it.</p>
-<p>To request a free trial, you will need to go to this link: https://www.bluebits.be/en/trikker/try/. You will need to enter your email address and agree to the terms and conditions. You will receive an email with your trial license key and instructions on how to activate it. The trial license key will allow you to use Bluebits Trikker for 14 days with full functionality.</p>
-<p>To activate Bluebits Trikker with your license key, you will need to open the software and go to Help > Activate License. You will need to enter your license key and click on Activate. The software will verify your license key online and activate it on your computer. You can now use Bluebits Trikker without any limitations.</p>
-<h2>Conclusion</h2>
-<p>Bluebits Trikker is a powerful software for drawing electrical diagrams and schematics. It is easy to use and has many features that make it a great tool for electricians, engineers, and hobbyists. However, it is not free and requires a license key to activate it.</p>
-<p>If you want to use Bluebits Trikker without paying for it, you might be tempted to look for a crack version online. However, this is not a good idea as it can expose you to legal issues and security risks. Moreover, you might not get the full functionality of the software or face errors and bugs that can ruin your work.</p>
-<p>Therefore, it is better to avoid using a crack version of Bluebits Trikker and instead look for a legitimate way to get the software. You can download Bluebits Trikker from the official website of the developer and activate it with a license key that you can purchase or request for free.</p>
-<p>We hope this article has helped you understand how to download and use Bluebits Trikker V1.5.20 legally and safely.</p>
-<h2>What are the Benefits of Using Bluebits Trikker V1.5.20</h2>
-<p>Bluebits Trikker V1.5.20 is a powerful software that offers many benefits for users who want to draw electrical diagrams and schematics. Some of the benefits are:</p>
-<ul>
-<li>It is easy to use and has a user-friendly interface that allows you to create and edit diagrams with simple drag and drop actions.</li>
-<li>It has a large library of symbols and components that you can use to draw any type of electrical installation, such as lighting, sockets, switches, sensors, motors, generators, etc.</li>
-<li>It can automatically calculate the wire lengths, cross-sections, voltage drops, and short-circuit currents for your diagrams and display them in a clear and concise way.</li>
-<li>It can generate professional reports and documents for your diagrams, such as single-wire diagrams, situation diagrams, labels, bills of materials, etc.</li>
-<li>It can export your diagrams to various formats, such as PDF, DWG, DXF, JPG, PNG, etc., so you can share them with others or print them out.</li>
-</ul>
-<h2>What are the Risks of Using Bluebits Trikker V1.5.20 Crack</h2>
-<p>Bluebits Trikker V1.5.20 crack is a modified version of the software that bypasses the license verification and allows you to use it for free. However, using a crack version is not only illegal but also risky. Some of the risks are:</p>
-<ul>
-<li>It can contain viruses, malware, or spyware that can infect your computer and compromise your security and privacy. You might lose your data, personal information, or money to hackers or cybercriminals.</li>
-<li>It can have errors and bugs that can cause your software to crash or malfunction. You might lose your work or damage your diagrams.</li>
-<li>It can have limited functionality or features that are not available in the original version. You might miss out on some important tools or updates that can improve your work.</li>
-<li>It can violate the terms and conditions of the developer and expose you to legal issues and penalties. You might face lawsuits, fines, or even jail time for using pirated software.</li>
-</ul>
-<h2>How to Avoid Using Bluebits Trikker V1.5.20 Crack</h2>
-<p>The best way to avoid using Bluebits Trikker V1.5.20 crack is to use the original version of the software that you can download from the official website of the developer. You can either purchase a license key or request a free trial to activate the software legally and safely.</p>
-<p>Purchasing a license key will give you full access to the software for a lifetime. You will also get free updates and support from the developer. You can choose the number of licenses you want depending on how many computers you want to use the software on.</p>
-<p>Requesting a free trial will give you full access to the software for 14 days. You will be able to test all the features and functions of the software and see if it suits your needs. You will also be able to save and export your diagrams during the trial period.</p>
-<p>To purchase a license key or request a free trial, you will need to visit the developer's website and follow the instructions on how to download and activate the software. You will need an email address and an internet connection for this process.</p>
-<h2>What are the Alternatives to Bluebits Trikker V1.5.20</h2>
-<p>Bluebits Trikker V1.5.20 is not the only software that can help you draw electrical diagrams and schematics. There are other alternatives that you can try if you are looking for different features, prices, or platforms. Some of the alternatives are:</p>
-<ul>
-<li>EPLAN Electric P8: This is a professional software that can help you design, document, and manage electrical engineering projects. It has a comprehensive database of components, symbols, and standards that you can use to create accurate and consistent diagrams. It also has a powerful automation and simulation tool that can help you optimize your designs and reduce errors. It is compatible with Windows and requires a subscription to use.</li>
-<li>AutoCAD Electrical: This is a software that can help you create and modify electrical control systems. It has a rich set of tools and features that can help you design, draft, and document electrical circuits, panels, and PLCs. It also has a large library of symbols and parts that you can use to create industry-standard diagrams. It is compatible with Windows and Mac and requires a subscription to use.</li>
-<li>Electra E8: This is a software that can help you create electrical, pneumatic, and hydraulic diagrams in minutes. It is an add-on for Microsoft Visio that enhances its functionality and usability for electrical engineering purposes. It has a simple and intuitive interface that allows you to drag and drop symbols, components, and wires to create your diagrams. It also has a smart panel layout tool that can help you arrange your components neatly and efficiently. It is compatible with Windows and requires a one-time purchase to use.</li>
-</ul>
-<h2>How to Learn Bluebits Trikker V1.5.20</h2>
-<p>Bluebits Trikker V1.5.20 is a software that is easy to use and has a user-friendly interface. However, if you want to learn how to use it effectively and efficiently, you might need some guidance and resources. Here are some ways that you can learn Bluebits Trikker V1.5.20:</p>
-<ul>
-<li>Watch the tutorial videos: The developer of Bluebits Trikker has created several tutorial videos that can help you learn the basics and advanced features of the software. You can find the videos on their YouTube channel here: https://www.youtube.com/user/BluebitsTrikker/videos. You can also access the videos from within the software by going to Help > Tutorial Videos.</li>
-<li>Read the user manual: The developer of Bluebits Trikker has also created a detailed user manual that can help you understand the functions and options of the software. You can find the user manual on their website here: https://www.bluebits.be/en/trikker/manual/. You can also access the user manual from within the software by going to Help > User Manual.</li>
-<li>Join the forum: The developer of Bluebits Trikker has also created a forum where you can ask questions, share tips, and get support from other users of the software. You can find the forum on their website here: https://www.bluebits.be/en/trikker/forum/. You will need to register an account to join the forum.</li>
-</ul>
-<h2>Conclusion</h2>
-<p>Bluebits Trikker V1.5.20 is a powerful software for drawing electrical diagrams and schematics. It is easy to use and has many features that make it a great tool for electricians, engineers, and hobbyists. However, it is not free and requires a license key to activate it.</p>
-<p>If you want to use Bluebits Trikker without paying for it, you might be tempted to look for a crack version online. However, this is not a good idea as it can expose you to legal issues and security risks. Moreover, you might not get the full functionality of the software or face errors and bugs that can ruin your work.</p>
-<p>Therefore, it is better to avoid using a crack version of Bluebits Trikker and instead look for a legitimate way to get the software. You can download Bluebits Trikker from the official website of the developer and activate it with a license key that you can purchase or request for free. You can also try other alternatives that might suit your needs better.</p>
-<p>We hope this article has helped you understand how to download and use Bluebits Trikker V1.5.20 legally and safely. If you have any questions or feedback, please feel free to leave a comment below.</p> 3cee63e6c2<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/diacanFperku/AutoGPT/Mixer Grinder Working Principle Pdf Download BEST.md b/spaces/diacanFperku/AutoGPT/Mixer Grinder Working Principle Pdf Download BEST.md
deleted file mode 100644
index 7fc6718d6d65fef5fc61fc37e6636c672c5b1b77..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Mixer Grinder Working Principle Pdf Download BEST.md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>Mixer Grinder Working Principle Pdf Download</h2><br /><p><b><b>Download</b> &#8230;&#8230;&#8230; <a href="https://gohhs.com/2uFVeS">https://gohhs.com/2uFVeS</a></b></p><br /><br />
-
-works. Grinding machines have some special precautions that must be observed. . Bench type tool and grinder, see fig. 5-4, were. Cylindrical grinders are commonly used for grinding external surfaces such as . Rice. 5-4: The main methods that can be used for grinding the outer surfaces of parts. Rice. 5-4: The main methods that can be used for grinding the outer surfaces of parts. Rice. 5-4: The main methods that can be used for grinding the outer surfaces of parts. Rice. 5-5. The methods used in grinding the surfaces shown in fig. 5-4. Rice. 5-5: Methods used in grinding the surfaces shown in fig. 5-4. Fig. 8a78ff9644<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/diacanFperku/AutoGPT/Native Instruments Reflektor IR Library For Guitar Rig WiN MacOS TOP Free Download.md b/spaces/diacanFperku/AutoGPT/Native Instruments Reflektor IR Library For Guitar Rig WiN MacOS TOP Free Download.md
deleted file mode 100644
index 7e5c6d1cb75647e62f4e58ee5c677d51b183b2ac..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Native Instruments Reflektor IR Library For Guitar Rig WiN MacOS TOP Free Download.md	
+++ /dev/null
@@ -1,26 +0,0 @@
-<h2>Native Instruments Reflektor IR Library for Guitar Rig WiN MacOS free download</h2><br /><p><b><b>Download</b> &#10004; <a href="https://gohhs.com/2uFTH4">https://gohhs.com/2uFTH4</a></b></p><br /><br />
-
-Native Instruments Guitar Rig 1.1 MacOSX 1 / No Registration. Native Instruments REFLECtor IR Library for Guitar Rig. Download the.BIG MAC OS X iMac 7.7.1.dmg image here at MacOSDownload.Info.The missing level is saved, the water is green and the bars show the saved level and the goal.
-
-Game can be played in: Low resolution, 8x8, 8x12, 8x16, 8x20, 16x16, 16x20, 16x24, 16x32, 16x32 (Detail), 16x48, 16x48 (Detail), 16x64.
-
-Game has 11 levels, it can be saved.
-
-Patching an existing level or completing it (getting all stars) from the list of levels. It's the same thing.
-
-It's a function of the game engine, not the game itself.
-
-If the game was not saved, the level will be automatically saved.
-
-Another caveat, this doesn't work for all levels. There are only a few that will work in this way. The reason is that most of the levels are derived from a human blueprint. The problem is that the computer is not a human. It does things in a certain way. However, if I can still use it, it will be possible to save every level without needing to use the space bar.
-
-I don't know how to do this. But I'll try to give a clear description of how it works.
-
-First of all, the path will be a number of steps. For the first level, the number of steps is 1, the second level, 2, and so on. The number of steps is equal to the number of pixels. If the level is created with the default width and height, it will have 4 steps of width and 6 steps of height. It is the same as if we multiplied the width by 4 and the height by 6. For example, in a 8x12 game, it will be equal to 8x12x4x6, or 64.
-
-However, this is not the only way to do this. For example, it could also be 4x12x4x6 or 4x6x12x4.
-
-Another possibility is that I'll place the level in a giant square. For example, if the level is 8x16, there will be 16 x 8. The 4fefd39f24<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/dingding27/bingo/README.md b/spaces/dingding27/bingo/README.md
deleted file mode 100644
index 5d6936218874c647b5d22e13ad4be7edb8936f92..0000000000000000000000000000000000000000
--- a/spaces/dingding27/bingo/README.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: bingo
-emoji: 😊
-colorFrom: red
-colorTo: red
-sdk: docker
-license: mit
-duplicated_from: hf4all/bingo
----
-
-<div align="center">
-
-# Bingo 
-
-Bingo，一个让你呼吸顺畅 New Bing。
-
-高度还原 New Bing 网页版的主要操作，国内可用，兼容绝大多数微软 Bing AI 的功能，可自行部署使用。
-
-![Github stars](https://badgen.net/github/stars/weaigc/bingo?icon=github&label=stars)
-![Gthub issues](https://img.shields.io/github/issues/weaigc/bingo)
-[![docker build](https://github.com/weaigc/bingo/actions/workflows/docker.yml/badge.svg)](https://hub.docker.com/repository/docker/weaigc/bingo/)
-[![docker hub](https://badgen.net/docker/size/weaigc/bingo?icon=docker&label=image%20size)](https://hub.docker.com/repository/docker/weaigc/bingo/)
-[![MIT License](https://img.shields.io/badge/license-MIT-97c50f)](https://github.com/weaigc/bingo/blob/main/license)
-
-问题反馈请前往 https://github.com/weaigc/bingo/issues
-</div>
-
-
diff --git a/spaces/dongyi/MMFS/data/deprecated/landmark_data.py b/spaces/dongyi/MMFS/data/deprecated/landmark_data.py
deleted file mode 100644
index 8a624c755b22354d417ba322d556381199f82b42..0000000000000000000000000000000000000000
--- a/spaces/dongyi/MMFS/data/deprecated/landmark_data.py
+++ /dev/null
@@ -1,89 +0,0 @@
-import os
-from PIL import Image
-import numpy as np
-from utils.data_utils import check_create_shuffled_order, check_equal_length
-
-def landmark_path_to_numpy(lmk_path, image_path, image_tensor):
-    """Convert an landmark path to the actual landmarks in a numpy array. Also applies scaling to the landmarks
-    according to final image' size.
-
-    Parameters:
-        lmk_path  --  the landmark file path.
-        image_path  --  the original image file path.
-        image_tensor  --  the image tensor after all transformations.
-    """
-    lmk = np.load(lmk_path)
-    ow, oh = Image.open(image_path).size
-    h, w = image_tensor.size()[1:]
-    lmk[:, 0] *= w / ow
-    lmk[:, 1] *= h / oh
-    return lmk
-
-def add_landmark_data(data, config, paired_data_order):
-    A_lmk_paths = []
-    B_lmk_paths = []
-
-    if config['dataset']['paired_' + config['common']['phase'] + '_filelist'] != '':
-        paired_data_file = open(config['dataset']['paired_' + config['common']['phase'] + '_filelist'], 'r')
-        Lines = paired_data_file.readlines()
-        paired_data_order = check_create_shuffled_order(Lines, paired_data_order)
-        check_equal_length(Lines, paired_data_order, data)
-        for i in paired_data_order:
-            line = Lines[i]
-            if not config['dataset']['use_absolute_datafile']:
-                file3 = os.path.join(config['dataset']['dataroot'], line.split(" ")[2]).strip()
-                file4 = os.path.join(config['dataset']['dataroot'], line.split(" ")[3]).strip()
-            else:
-                file3 = line.split(" ")[2].strip()
-                file4 = line.split(" ")[3].strip()
-            if os.path.exists(file3) and os.path.exists(file4):
-                A_lmk_paths.append(file3)
-                B_lmk_paths.append(file4)
-        paired_data_file.close()
-    elif config['dataset']['paired_' + config['common']['phase'] + 'A_folder'] != '' and \
-            config['dataset']['paired_' + config['common']['phase'] + 'B_folder'] != '' and \
-            os.path.exists(config['dataset']['paired_' + config['common']['phase'] + 'A_lmk_folder']) and \
-            os.path.exists(config['dataset']['paired_' + config['common']['phase'] + 'B_lmk_folder']):
-        dir_A = config['dataset']['paired_' + config['common']['phase'] + 'A_folder']
-        dir_A_lmk = config['dataset']['paired_' + config['common']['phase'] + 'A_lmk_folder']
-        dir_B_lmk = config['dataset']['paired_' + config['common']['phase'] + 'B_lmk_folder']
-        filenames = os.listdir(dir_A)
-        paired_data_order = check_create_shuffled_order(filenames, paired_data_order)
-        check_equal_length(filenames, paired_data_order, data)
-        for i in paired_data_order:
-            filename = filenames[i]
-            A_lmk_path = os.path.join(dir_A_lmk, os.path.splitext(filename)[0] + '.npy')
-            B_lmk_path = os.path.join(dir_B_lmk, os.path.splitext(filename)[0] + '.npy')
-            if os.path.exists(A_lmk_path) and os.path.exists(B_lmk_path):
-                A_lmk_paths.append(A_lmk_path)
-                B_lmk_paths.append(B_lmk_path)
-    else:
-        dir_A = os.path.join(config['dataset']['dataroot'], config['common']['phase'] + 'pairedA')
-        dir_A_lmk = os.path.join(config['dataset']['dataroot'], config['common']['phase'] + 'pairedA_lmk')
-        dir_B_lmk = os.path.join(config['dataset']['dataroot'], config['common']['phase'] + 'pairedB_lmk')
-        if os.path.exists(dir_A_lmk) and os.path.exists(dir_B_lmk):
-            filenames = os.listdir(dir_A)
-            paired_data_order = check_create_shuffled_order(filenames, paired_data_order)
-            check_equal_length(filenames, paired_data_order, data)
-            for i in paired_data_order:
-                filename = filenames[i]
-                A_lmk_path = os.path.join(dir_A_lmk, os.path.splitext(filename)[0] + '.npy')
-                B_lmk_path = os.path.join(dir_B_lmk, os.path.splitext(filename)[0] + '.npy')
-                if os.path.exists(A_lmk_path) and os.path.exists(B_lmk_path):
-                    A_lmk_paths.append(A_lmk_path)
-                    B_lmk_paths.append(B_lmk_path)
-        else:
-            print(dir_A_lmk + " or " + dir_B_lmk + " doesn't exist. Skipping landmark data.")
-
-    data['A_lmk_path'] = A_lmk_paths
-    data['B_lmk_path'] = B_lmk_paths
-
-    return paired_data_order
-
-
-def apply_landmark_transforms(index, data, return_dict):
-    if len(data['A_lmk_path']) > 0:
-        return_dict['A_lmk'] = landmark_path_to_numpy(data['A_lmk_path'][index], data['paired_A_path'][index], return_dict['paired_A'])
-        return_dict['B_lmk'] = landmark_path_to_numpy(data['B_lmk_path'][index], data['paired_B_path'][index], return_dict['paired_B'])
-        return_dict['A_lmk_path'] = data['A_lmk_path'][index]
-        return_dict['B_lmk_path'] = data['B_lmk_path'][index]
diff --git a/spaces/dragonSwing/annotate-anything/GroundingDINO/groundingdino/config/GroundingDINO_SwinB.py b/spaces/dragonSwing/annotate-anything/GroundingDINO/groundingdino/config/GroundingDINO_SwinB.py
deleted file mode 100644
index f490c4bbd598a35de43d36ceafcbd769e7ff21bf..0000000000000000000000000000000000000000
--- a/spaces/dragonSwing/annotate-anything/GroundingDINO/groundingdino/config/GroundingDINO_SwinB.py
+++ /dev/null
@@ -1,43 +0,0 @@
-batch_size = 1
-modelname = "groundingdino"
-backbone = "swin_B_384_22k"
-position_embedding = "sine"
-pe_temperatureH = 20
-pe_temperatureW = 20
-return_interm_indices = [1, 2, 3]
-backbone_freeze_keywords = None
-enc_layers = 6
-dec_layers = 6
-pre_norm = False
-dim_feedforward = 2048
-hidden_dim = 256
-dropout = 0.0
-nheads = 8
-num_queries = 900
-query_dim = 4
-num_patterns = 0
-num_feature_levels = 4
-enc_n_points = 4
-dec_n_points = 4
-two_stage_type = "standard"
-two_stage_bbox_embed_share = False
-two_stage_class_embed_share = False
-transformer_activation = "relu"
-dec_pred_bbox_embed_share = True
-dn_box_noise_scale = 1.0
-dn_label_noise_ratio = 0.5
-dn_label_coef = 1.0
-dn_bbox_coef = 1.0
-embed_init_tgt = True
-dn_labelbook_size = 2000
-max_text_len = 256
-text_encoder_type = "bert-base-uncased"
-use_text_enhancer = True
-use_fusion_layer = True
-use_checkpoint = True
-use_transformer_ckpt = True
-use_text_cross_attention = True
-text_dropout = 0.0
-fusion_dropout = 0.0
-fusion_droppath = 0.1
-sub_sentence_present = True
diff --git a/spaces/edenehuyh/BLIQ_ImageCaptioning/models/vit.py b/spaces/edenehuyh/BLIQ_ImageCaptioning/models/vit.py
deleted file mode 100644
index cec3d8e08ed4451d65392feb2e9f4848d1ef3899..0000000000000000000000000000000000000000
--- a/spaces/edenehuyh/BLIQ_ImageCaptioning/models/vit.py
+++ /dev/null
@@ -1,305 +0,0 @@
-'''
- * Copyright (c) 2022, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: BSD-3-Clause
- * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
- * By Junnan Li
- * Based on timm code base
- * https://github.com/rwightman/pytorch-image-models/tree/master/timm
-'''
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from functools import partial
-
-from timm.models.vision_transformer import _cfg, PatchEmbed
-from timm.models.registry import register_model
-from timm.models.layers import trunc_normal_, DropPath
-from timm.models.helpers import named_apply, adapt_input_conv
-
-from fairscale.nn.checkpoint.checkpoint_activations import checkpoint_wrapper
-
-class Mlp(nn.Module):
-    """ MLP as used in Vision Transformer, MLP-Mixer and related networks
-    """
-    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
-        super().__init__()
-        out_features = out_features or in_features
-        hidden_features = hidden_features or in_features
-        self.fc1 = nn.Linear(in_features, hidden_features)
-        self.act = act_layer()
-        self.fc2 = nn.Linear(hidden_features, out_features)
-        self.drop = nn.Dropout(drop)
-
-    def forward(self, x):
-        x = self.fc1(x)
-        x = self.act(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        x = self.drop(x)
-        return x
-
-
-class Attention(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
-        super().__init__()
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights
-        self.scale = qk_scale or head_dim ** -0.5
-        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-        self.attn_gradients = None
-        self.attention_map = None
-        
-    def save_attn_gradients(self, attn_gradients):
-        self.attn_gradients = attn_gradients
-        
-    def get_attn_gradients(self):
-        return self.attn_gradients
-    
-    def save_attention_map(self, attention_map):
-        self.attention_map = attention_map
-        
-    def get_attention_map(self):
-        return self.attention_map
-    
-    def forward(self, x, register_hook=False):
-        B, N, C = x.shape
-        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        q, k, v = qkv[0], qkv[1], qkv[2]   # make torchscript happy (cannot use tensor as tuple)
-
-        attn = (q @ k.transpose(-2, -1)) * self.scale
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-                
-        if register_hook:
-            self.save_attention_map(attn)
-            attn.register_hook(self.save_attn_gradients)        
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x
-
-
-class Block(nn.Module):
-
-    def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
-                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm, use_grad_checkpointing=False):
-        super().__init__()
-        self.norm1 = norm_layer(dim)
-        self.attn = Attention(
-            dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
-        # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
-        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
-        self.norm2 = norm_layer(dim)
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
-        if use_grad_checkpointing:
-            self.attn = checkpoint_wrapper(self.attn)
-            self.mlp = checkpoint_wrapper(self.mlp)
-
-    def forward(self, x, register_hook=False):
-        x = x + self.drop_path(self.attn(self.norm1(x), register_hook=register_hook))
-        x = x + self.drop_path(self.mlp(self.norm2(x)))
-        return x
-
-    
-class VisionTransformer(nn.Module):
-    """ Vision Transformer
-    A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`  -
-        https://arxiv.org/abs/2010.11929
-    """
-    def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12,
-                 num_heads=12, mlp_ratio=4., qkv_bias=True, qk_scale=None, representation_size=None,
-                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0., norm_layer=None, 
-                 use_grad_checkpointing=False, ckpt_layer=0):
-        """
-        Args:
-            img_size (int, tuple): input image size
-            patch_size (int, tuple): patch size
-            in_chans (int): number of input channels
-            num_classes (int): number of classes for classification head
-            embed_dim (int): embedding dimension
-            depth (int): depth of transformer
-            num_heads (int): number of attention heads
-            mlp_ratio (int): ratio of mlp hidden dim to embedding dim
-            qkv_bias (bool): enable bias for qkv if True
-            qk_scale (float): override default qk scale of head_dim ** -0.5 if set
-            representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
-            drop_rate (float): dropout rate
-            attn_drop_rate (float): attention dropout rate
-            drop_path_rate (float): stochastic depth rate
-            norm_layer: (nn.Module): normalization layer
-        """
-        super().__init__()
-        self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
-        norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)
-
-        self.patch_embed = PatchEmbed(
-            img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
-
-        num_patches = self.patch_embed.num_patches
-
-        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
-        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim))
-        self.pos_drop = nn.Dropout(p=drop_rate)
-
-        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
-        self.blocks = nn.ModuleList([
-            Block(
-                dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer,
-                use_grad_checkpointing=(use_grad_checkpointing and i>=depth-ckpt_layer)
-            )
-            for i in range(depth)])
-        self.norm = norm_layer(embed_dim)
-
-        trunc_normal_(self.pos_embed, std=.02)
-        trunc_normal_(self.cls_token, std=.02)
-        self.apply(self._init_weights)
-
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-
-    @torch.jit.ignore
-    def no_weight_decay(self):
-        return {'pos_embed', 'cls_token'}
-
-    def forward(self, x, register_blk=-1):
-        B = x.shape[0]
-        x = self.patch_embed(x)
-
-        cls_tokens = self.cls_token.expand(B, -1, -1)  # stole cls_tokens impl from Phil Wang, thanks
-        x = torch.cat((cls_tokens, x), dim=1)
-  
-        x = x + self.pos_embed[:,:x.size(1),:]
-        x = self.pos_drop(x)
-
-        for i,blk in enumerate(self.blocks):
-            x = blk(x, register_blk==i)
-        x = self.norm(x)
-        
-        return x
-
-    @torch.jit.ignore()
-    def load_pretrained(self, checkpoint_path, prefix=''):
-        _load_weights(self, checkpoint_path, prefix)
-        
-
-@torch.no_grad()
-def _load_weights(model: VisionTransformer, checkpoint_path: str, prefix: str = ''):
-    """ Load weights from .npz checkpoints for official Google Brain Flax implementation
-    """
-    import numpy as np
-
-    def _n2p(w, t=True):
-        if w.ndim == 4 and w.shape[0] == w.shape[1] == w.shape[2] == 1:
-            w = w.flatten()
-        if t:
-            if w.ndim == 4:
-                w = w.transpose([3, 2, 0, 1])
-            elif w.ndim == 3:
-                w = w.transpose([2, 0, 1])
-            elif w.ndim == 2:
-                w = w.transpose([1, 0])
-        return torch.from_numpy(w)
-
-    w = np.load(checkpoint_path)
-    if not prefix and 'opt/target/embedding/kernel' in w:
-        prefix = 'opt/target/'
-
-    if hasattr(model.patch_embed, 'backbone'):
-        # hybrid
-        backbone = model.patch_embed.backbone
-        stem_only = not hasattr(backbone, 'stem')
-        stem = backbone if stem_only else backbone.stem
-        stem.conv.weight.copy_(adapt_input_conv(stem.conv.weight.shape[1], _n2p(w[f'{prefix}conv_root/kernel'])))
-        stem.norm.weight.copy_(_n2p(w[f'{prefix}gn_root/scale']))
-        stem.norm.bias.copy_(_n2p(w[f'{prefix}gn_root/bias']))
-        if not stem_only:
-            for i, stage in enumerate(backbone.stages):
-                for j, block in enumerate(stage.blocks):
-                    bp = f'{prefix}block{i + 1}/unit{j + 1}/'
-                    for r in range(3):
-                        getattr(block, f'conv{r + 1}').weight.copy_(_n2p(w[f'{bp}conv{r + 1}/kernel']))
-                        getattr(block, f'norm{r + 1}').weight.copy_(_n2p(w[f'{bp}gn{r + 1}/scale']))
-                        getattr(block, f'norm{r + 1}').bias.copy_(_n2p(w[f'{bp}gn{r + 1}/bias']))
-                    if block.downsample is not None:
-                        block.downsample.conv.weight.copy_(_n2p(w[f'{bp}conv_proj/kernel']))
-                        block.downsample.norm.weight.copy_(_n2p(w[f'{bp}gn_proj/scale']))
-                        block.downsample.norm.bias.copy_(_n2p(w[f'{bp}gn_proj/bias']))
-        embed_conv_w = _n2p(w[f'{prefix}embedding/kernel'])
-    else:
-        embed_conv_w = adapt_input_conv(
-            model.patch_embed.proj.weight.shape[1], _n2p(w[f'{prefix}embedding/kernel']))
-    model.patch_embed.proj.weight.copy_(embed_conv_w)
-    model.patch_embed.proj.bias.copy_(_n2p(w[f'{prefix}embedding/bias']))
-    model.cls_token.copy_(_n2p(w[f'{prefix}cls'], t=False))
-    pos_embed_w = _n2p(w[f'{prefix}Transformer/posembed_input/pos_embedding'], t=False)
-    if pos_embed_w.shape != model.pos_embed.shape:
-        pos_embed_w = resize_pos_embed(  # resize pos embedding when different size from pretrained weights
-            pos_embed_w, model.pos_embed, getattr(model, 'num_tokens', 1), model.patch_embed.grid_size)
-    model.pos_embed.copy_(pos_embed_w)
-    model.norm.weight.copy_(_n2p(w[f'{prefix}Transformer/encoder_norm/scale']))
-    model.norm.bias.copy_(_n2p(w[f'{prefix}Transformer/encoder_norm/bias']))
-#     if isinstance(model.head, nn.Linear) and model.head.bias.shape[0] == w[f'{prefix}head/bias'].shape[-1]:
-#         model.head.weight.copy_(_n2p(w[f'{prefix}head/kernel']))
-#         model.head.bias.copy_(_n2p(w[f'{prefix}head/bias']))
-#     if isinstance(getattr(model.pre_logits, 'fc', None), nn.Linear) and f'{prefix}pre_logits/bias' in w:
-#         model.pre_logits.fc.weight.copy_(_n2p(w[f'{prefix}pre_logits/kernel']))
-#         model.pre_logits.fc.bias.copy_(_n2p(w[f'{prefix}pre_logits/bias']))
-    for i, block in enumerate(model.blocks.children()):
-        block_prefix = f'{prefix}Transformer/encoderblock_{i}/'
-        mha_prefix = block_prefix + 'MultiHeadDotProductAttention_1/'
-        block.norm1.weight.copy_(_n2p(w[f'{block_prefix}LayerNorm_0/scale']))
-        block.norm1.bias.copy_(_n2p(w[f'{block_prefix}LayerNorm_0/bias']))
-        block.attn.qkv.weight.copy_(torch.cat([
-            _n2p(w[f'{mha_prefix}{n}/kernel'], t=False).flatten(1).T for n in ('query', 'key', 'value')]))
-        block.attn.qkv.bias.copy_(torch.cat([
-            _n2p(w[f'{mha_prefix}{n}/bias'], t=False).reshape(-1) for n in ('query', 'key', 'value')]))
-        block.attn.proj.weight.copy_(_n2p(w[f'{mha_prefix}out/kernel']).flatten(1))
-        block.attn.proj.bias.copy_(_n2p(w[f'{mha_prefix}out/bias']))
-        for r in range(2):
-            getattr(block.mlp, f'fc{r + 1}').weight.copy_(_n2p(w[f'{block_prefix}MlpBlock_3/Dense_{r}/kernel']))
-            getattr(block.mlp, f'fc{r + 1}').bias.copy_(_n2p(w[f'{block_prefix}MlpBlock_3/Dense_{r}/bias']))
-        block.norm2.weight.copy_(_n2p(w[f'{block_prefix}LayerNorm_2/scale']))
-        block.norm2.bias.copy_(_n2p(w[f'{block_prefix}LayerNorm_2/bias']))
-
-            
-def interpolate_pos_embed(pos_embed_checkpoint, visual_encoder):        
-    # interpolate position embedding
-    embedding_size = pos_embed_checkpoint.shape[-1]
-    num_patches = visual_encoder.patch_embed.num_patches
-    num_extra_tokens = visual_encoder.pos_embed.shape[-2] - num_patches
-    # height (== width) for the checkpoint position embedding
-    orig_size = int((pos_embed_checkpoint.shape[-2] - num_extra_tokens) ** 0.5)
-    # height (== width) for the new position embedding
-    new_size = int(num_patches ** 0.5)
-
-    if orig_size!=new_size:
-        # class_token and dist_token are kept unchanged
-        extra_tokens = pos_embed_checkpoint[:, :num_extra_tokens]
-        # only the position tokens are interpolated
-        pos_tokens = pos_embed_checkpoint[:, num_extra_tokens:]
-        pos_tokens = pos_tokens.reshape(-1, orig_size, orig_size, embedding_size).permute(0, 3, 1, 2)
-        pos_tokens = torch.nn.functional.interpolate(
-            pos_tokens, size=(new_size, new_size), mode='bicubic', align_corners=False)
-        pos_tokens = pos_tokens.permute(0, 2, 3, 1).flatten(1, 2)
-        new_pos_embed = torch.cat((extra_tokens, pos_tokens), dim=1)
-        print('reshape position embedding from %d to %d'%(orig_size ** 2,new_size ** 2))
-        
-        return new_pos_embed    
-    else:
-        return pos_embed_checkpoint
\ No newline at end of file
diff --git a/spaces/editing-images/ledits/constants.py b/spaces/editing-images/ledits/constants.py
deleted file mode 100644
index 4a04f2ad966b5296d4cbb2f7ff7346b1221ba9cf..0000000000000000000000000000000000000000
--- a/spaces/editing-images/ledits/constants.py
+++ /dev/null
@@ -1,26 +0,0 @@
-###############
-# conststants #
-###############
-DEFAULT_TARGET_GUIDANCE_SCALE = 15
-DEFAULT_SOURCE_GUIDANCE_SCALE = 3.5
-DEFAULT_DIFFUSION_STEPS = 100
-DEFAULT_SKIP_STEPS = 36
-DEFAULT_SEED = 0
-
-
-DEFAULT_SEGA_CONCEPT_GUIDANCE_SCALE = 7
-DEFAULT_WARMUP_STEPS = 2
-DEFAULT_THRESHOLD = 0.95
-DEFAULT_NEGATIVE_GUIDANCE=False
-
-STYLE_SEGA_CONCEPT_GUIDANCE_SCALE = 8
-STYLE_WARMUP_STEPS = 2
-STYLE_THRESHOLD = 0.92
-
-FACE_SEGA_CONCEPT_GUIDANCE_SCALE = 5
-FACE_WARMUP_STEPS = 2
-FACE_THRESHOLD = 0.95
-
-OBJECT_SEGA_CONCEPT_GUIDANCE_SCALE = 15
-OBJECT_WARMUP_STEPS = 5
-OBJECT_THRESHOLD = 0.95
\ No newline at end of file
diff --git a/spaces/ejschwartz/function-method-detector/Dockerfile b/spaces/ejschwartz/function-method-detector/Dockerfile
deleted file mode 100644
index c81742dd9a2d789f2d37951738b648caaa4d952f..0000000000000000000000000000000000000000
--- a/spaces/ejschwartz/function-method-detector/Dockerfile
+++ /dev/null
@@ -1,32 +0,0 @@
-## Based on https://huggingface.co/spaces/sayakpaul/demo-docker-gradio/blob/main/Dockerfile
-
-FROM seipharos/pharos
-
-WORKDIR /code
-
-COPY ./requirements.txt /code/requirements.txt
-
-RUN apt-get -y update && apt-get -y install python3-pip
-
-
-# Set up a new user named "user" with user ID 1000
-RUN useradd -m -u 1000 user
-
-# Switch to the "user" user
-USER user
-
-RUN pip3 install --no-cache-dir --upgrade setuptools pip
-
-RUN pip3 install --no-cache-dir --upgrade -r /code/requirements.txt
-
-# Set home to the user's home directory
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH
-
-# Set the working directory to the user's home directory
-WORKDIR $HOME/app
-
-# Copy the current directory contents into the container at $HOME/app setting the owner to the user
-COPY --chown=user . $HOME/app
-
-CMD ["python3", "app.py"]
diff --git a/spaces/eswat/Image-and-3D-Model-Creator/PIFu/lib/renderer/gl/prt_render.py b/spaces/eswat/Image-and-3D-Model-Creator/PIFu/lib/renderer/gl/prt_render.py
deleted file mode 100644
index 92c8a6257f776ab0c803a78a3af7c43a4333c3f9..0000000000000000000000000000000000000000
--- a/spaces/eswat/Image-and-3D-Model-Creator/PIFu/lib/renderer/gl/prt_render.py
+++ /dev/null
@@ -1,350 +0,0 @@
-import numpy as np
-import random
-
-from .framework import *
-from .cam_render import CamRender
-
-class PRTRender(CamRender):
-    def __init__(self, width=1600, height=1200, name='PRT Renderer', uv_mode=False, ms_rate=1, egl=False):
-        program_files = ['prt.vs', 'prt.fs'] if not uv_mode else ['prt_uv.vs', 'prt_uv.fs']
-        CamRender.__init__(self, width, height, name, program_files=program_files, color_size=8, ms_rate=ms_rate, egl=egl)
-
-        # WARNING: this differs from vertex_buffer and vertex_data in Render
-        self.vert_buffer = {}
-        self.vert_data = {}
-
-        self.norm_buffer = {}
-        self.norm_data = {}
-
-        self.tan_buffer = {}
-        self.tan_data = {}
-
-        self.btan_buffer = {}
-        self.btan_data = {}
-
-        self.prt1_buffer = {}
-        self.prt1_data = {}
-        self.prt2_buffer = {}
-        self.prt2_data = {}        
-        self.prt3_buffer = {}
-        self.prt3_data = {}
-
-        self.uv_buffer = {}
-        self.uv_data = {}
-
-        self.render_texture_mat = {}
-
-        self.vertex_dim = {}
-        self.n_vertices = {}
-
-        self.norm_mat_unif = glGetUniformLocation(self.program, 'NormMat')
-        self.normalize_matrix = np.eye(4)
-
-        self.shcoeff_unif = glGetUniformLocation(self.program, 'SHCoeffs')
-        self.shcoeffs = np.zeros((9,3))
-        self.shcoeffs[0,:] = 1.0
-        #self.shcoeffs[1:,:] = np.random.rand(8,3)
-
-        self.hasAlbedoUnif = glGetUniformLocation(self.program, 'hasAlbedoMap')
-        self.hasNormalUnif = glGetUniformLocation(self.program, 'hasNormalMap')
-
-        self.analyticUnif = glGetUniformLocation(self.program, 'analytic')
-        self.analytic = False
-
-        self.rot_mat_unif = glGetUniformLocation(self.program, 'RotMat')
-        self.rot_matrix = np.eye(3)
-
-    def set_texture(self, mat_name, smplr_name, texture):
-        # texture_image: H x W x 3
-        width = texture.shape[1]
-        height = texture.shape[0]
-        texture = np.flip(texture, 0)
-        img_data = np.fromstring(texture.tostring(), np.uint8)
-
-        if mat_name not in self.render_texture_mat:
-            self.render_texture_mat[mat_name] = {} 
-        if smplr_name in self.render_texture_mat[mat_name].keys():
-            glDeleteTextures([self.render_texture_mat[mat_name][smplr_name]])
-            del self.render_texture_mat[mat_name][smplr_name]
-        self.render_texture_mat[mat_name][smplr_name] = glGenTextures(1)
-        glActiveTexture(GL_TEXTURE0)
-        
-        glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
-        glBindTexture(GL_TEXTURE_2D, self.render_texture_mat[mat_name][smplr_name])
-
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, img_data)
-        
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 3)
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR)
-
-        glGenerateMipmap(GL_TEXTURE_2D)
-        
-    def set_albedo(self, texture_image, mat_name='all'):
-        self.set_texture(mat_name, 'AlbedoMap', texture_image)
-
-    def set_normal_map(self, texture_image, mat_name='all'):
-        self.set_texture(mat_name, 'NormalMap', texture_image)
-
-    def set_mesh(self, vertices, faces, norms, faces_nml, uvs, faces_uvs, prt, faces_prt, tans, bitans, mat_name='all'):
-        self.vert_data[mat_name] = vertices[faces.reshape([-1])]
-        self.n_vertices[mat_name] = self.vert_data[mat_name].shape[0]
-        self.vertex_dim[mat_name] = self.vert_data[mat_name].shape[1]
-
-        if mat_name not in self.vert_buffer.keys():
-            self.vert_buffer[mat_name] = glGenBuffers(1)
-        glBindBuffer(GL_ARRAY_BUFFER, self.vert_buffer[mat_name])
-        glBufferData(GL_ARRAY_BUFFER, self.vert_data[mat_name], GL_STATIC_DRAW)
-
-        self.uv_data[mat_name] = uvs[faces_uvs.reshape([-1])]
-        if mat_name not in self.uv_buffer.keys():
-            self.uv_buffer[mat_name] = glGenBuffers(1)
-        glBindBuffer(GL_ARRAY_BUFFER, self.uv_buffer[mat_name])
-        glBufferData(GL_ARRAY_BUFFER, self.uv_data[mat_name], GL_STATIC_DRAW)
-
-        self.norm_data[mat_name] = norms[faces_nml.reshape([-1])]
-        if mat_name not in self.norm_buffer.keys():
-            self.norm_buffer[mat_name] = glGenBuffers(1)
-        glBindBuffer(GL_ARRAY_BUFFER, self.norm_buffer[mat_name])
-        glBufferData(GL_ARRAY_BUFFER, self.norm_data[mat_name], GL_STATIC_DRAW)
-
-        self.tan_data[mat_name] = tans[faces_nml.reshape([-1])]
-        if mat_name not in self.tan_buffer.keys():
-            self.tan_buffer[mat_name] = glGenBuffers(1)
-        glBindBuffer(GL_ARRAY_BUFFER, self.tan_buffer[mat_name])
-        glBufferData(GL_ARRAY_BUFFER, self.tan_data[mat_name], GL_STATIC_DRAW)
-
-        self.btan_data[mat_name] = bitans[faces_nml.reshape([-1])]
-        if mat_name not in self.btan_buffer.keys():
-            self.btan_buffer[mat_name] = glGenBuffers(1)
-        glBindBuffer(GL_ARRAY_BUFFER, self.btan_buffer[mat_name])
-        glBufferData(GL_ARRAY_BUFFER, self.btan_data[mat_name], GL_STATIC_DRAW)
-
-        self.prt1_data[mat_name] = prt[faces_prt.reshape([-1])][:,:3]
-        self.prt2_data[mat_name] = prt[faces_prt.reshape([-1])][:,3:6]
-        self.prt3_data[mat_name] = prt[faces_prt.reshape([-1])][:,6:]
-
-        if mat_name not in self.prt1_buffer.keys():
-            self.prt1_buffer[mat_name] = glGenBuffers(1)
-        if mat_name not in self.prt2_buffer.keys():
-            self.prt2_buffer[mat_name] = glGenBuffers(1)
-        if mat_name not in self.prt3_buffer.keys():
-            self.prt3_buffer[mat_name] = glGenBuffers(1)
-        glBindBuffer(GL_ARRAY_BUFFER, self.prt1_buffer[mat_name])
-        glBufferData(GL_ARRAY_BUFFER, self.prt1_data[mat_name], GL_STATIC_DRAW)
-        glBindBuffer(GL_ARRAY_BUFFER, self.prt2_buffer[mat_name])
-        glBufferData(GL_ARRAY_BUFFER, self.prt2_data[mat_name], GL_STATIC_DRAW)
-        glBindBuffer(GL_ARRAY_BUFFER, self.prt3_buffer[mat_name])
-        glBufferData(GL_ARRAY_BUFFER, self.prt3_data[mat_name], GL_STATIC_DRAW)
-        
-        glBindBuffer(GL_ARRAY_BUFFER, 0)
-
-    def set_mesh_mtl(self, vertices, faces, norms, faces_nml, uvs, faces_uvs, tans, bitans, prt):
-        for key in faces:
-            self.vert_data[key] = vertices[faces[key].reshape([-1])]
-            self.n_vertices[key] = self.vert_data[key].shape[0]
-            self.vertex_dim[key] = self.vert_data[key].shape[1]
-
-            if key not in self.vert_buffer.keys():
-                self.vert_buffer[key] = glGenBuffers(1)
-            glBindBuffer(GL_ARRAY_BUFFER, self.vert_buffer[key])
-            glBufferData(GL_ARRAY_BUFFER, self.vert_data[key], GL_STATIC_DRAW)
-
-            self.uv_data[key] = uvs[faces_uvs[key].reshape([-1])]
-            if key not in self.uv_buffer.keys():
-                self.uv_buffer[key] = glGenBuffers(1)
-            glBindBuffer(GL_ARRAY_BUFFER, self.uv_buffer[key])
-            glBufferData(GL_ARRAY_BUFFER, self.uv_data[key], GL_STATIC_DRAW)
-
-            self.norm_data[key] = norms[faces_nml[key].reshape([-1])]
-            if key not in self.norm_buffer.keys():
-                self.norm_buffer[key] = glGenBuffers(1)
-            glBindBuffer(GL_ARRAY_BUFFER, self.norm_buffer[key])
-            glBufferData(GL_ARRAY_BUFFER, self.norm_data[key], GL_STATIC_DRAW)
-
-            self.tan_data[key] = tans[faces_nml[key].reshape([-1])]
-            if key not in self.tan_buffer.keys():
-                self.tan_buffer[key] = glGenBuffers(1)
-            glBindBuffer(GL_ARRAY_BUFFER, self.tan_buffer[key])
-            glBufferData(GL_ARRAY_BUFFER, self.tan_data[key], GL_STATIC_DRAW)
-
-            self.btan_data[key] = bitans[faces_nml[key].reshape([-1])]
-            if key not in self.btan_buffer.keys():
-                self.btan_buffer[key] = glGenBuffers(1)
-            glBindBuffer(GL_ARRAY_BUFFER, self.btan_buffer[key])
-            glBufferData(GL_ARRAY_BUFFER, self.btan_data[key], GL_STATIC_DRAW)
-
-            self.prt1_data[key] = prt[faces[key].reshape([-1])][:,:3]
-            self.prt2_data[key] = prt[faces[key].reshape([-1])][:,3:6]
-            self.prt3_data[key] = prt[faces[key].reshape([-1])][:,6:]
-
-            if key not in self.prt1_buffer.keys():
-                self.prt1_buffer[key] = glGenBuffers(1)
-            if key not in self.prt2_buffer.keys():
-                self.prt2_buffer[key] = glGenBuffers(1)
-            if key not in self.prt3_buffer.keys():
-                self.prt3_buffer[key] = glGenBuffers(1)
-            glBindBuffer(GL_ARRAY_BUFFER, self.prt1_buffer[key])
-            glBufferData(GL_ARRAY_BUFFER, self.prt1_data[key], GL_STATIC_DRAW)
-            glBindBuffer(GL_ARRAY_BUFFER, self.prt2_buffer[key])
-            glBufferData(GL_ARRAY_BUFFER, self.prt2_data[key], GL_STATIC_DRAW)
-            glBindBuffer(GL_ARRAY_BUFFER, self.prt3_buffer[key])
-            glBufferData(GL_ARRAY_BUFFER, self.prt3_data[key], GL_STATIC_DRAW)
-
-        glBindBuffer(GL_ARRAY_BUFFER, 0)
-
-    def cleanup(self):
-        
-        glBindBuffer(GL_ARRAY_BUFFER, 0)
-        for key in self.vert_data:
-            glDeleteBuffers(1, [self.vert_buffer[key]])
-            glDeleteBuffers(1, [self.norm_buffer[key]])
-            glDeleteBuffers(1, [self.uv_buffer[key]])
-
-            glDeleteBuffers(1, [self.tan_buffer[key]])
-            glDeleteBuffers(1, [self.btan_buffer[key]])
-            glDeleteBuffers(1, [self.prt1_buffer[key]])
-            glDeleteBuffers(1, [self.prt2_buffer[key]])
-            glDeleteBuffers(1, [self.prt3_buffer[key]])
-
-            glDeleteBuffers(1, [])
-
-            for smplr in self.render_texture_mat[key]:
-                glDeleteTextures([self.render_texture_mat[key][smplr]])
-
-        self.vert_buffer = {}
-        self.vert_data = {}
-
-        self.norm_buffer = {}
-        self.norm_data = {}
-
-        self.tan_buffer = {}
-        self.tan_data = {}
-
-        self.btan_buffer = {}
-        self.btan_data = {}
-
-        self.prt1_buffer = {}
-        self.prt1_data = {}
-
-        self.prt2_buffer = {}
-        self.prt2_data = {}
-
-        self.prt3_buffer = {}
-        self.prt3_data = {}
-
-        self.uv_buffer = {}
-        self.uv_data = {}
-
-        self.render_texture_mat = {}
-
-        self.vertex_dim = {}
-        self.n_vertices = {}
-    
-    def randomize_sh(self):
-        self.shcoeffs[0,:] = 0.8
-        self.shcoeffs[1:,:] = 1.0*np.random.rand(8,3)
-
-    def set_sh(self, sh):
-        self.shcoeffs = sh
-
-    def set_norm_mat(self, scale, center):
-        N = np.eye(4)
-        N[:3, :3] = scale*np.eye(3)
-        N[:3, 3] = -scale*center
-
-        self.normalize_matrix = N
-
-    def draw(self):
-        self.draw_init()
-
-        glDisable(GL_BLEND)
-        #glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
-        glEnable(GL_MULTISAMPLE)
-
-        glUseProgram(self.program)
-        glUniformMatrix4fv(self.norm_mat_unif, 1, GL_FALSE, self.normalize_matrix.transpose())
-        glUniformMatrix4fv(self.model_mat_unif, 1, GL_FALSE, self.model_view_matrix.transpose())
-        glUniformMatrix4fv(self.persp_mat_unif, 1, GL_FALSE, self.projection_matrix.transpose())
-
-        if 'AlbedoMap' in self.render_texture_mat['all']:
-            glUniform1ui(self.hasAlbedoUnif, GLuint(1))
-        else:
-            glUniform1ui(self.hasAlbedoUnif, GLuint(0))
-
-        if 'NormalMap' in self.render_texture_mat['all']:
-            glUniform1ui(self.hasNormalUnif, GLuint(1))
-        else:
-            glUniform1ui(self.hasNormalUnif, GLuint(0))
-
-        glUniform1ui(self.analyticUnif, GLuint(1) if self.analytic else GLuint(0))
-
-        glUniform3fv(self.shcoeff_unif, 9, self.shcoeffs)
-
-        glUniformMatrix3fv(self.rot_mat_unif, 1, GL_FALSE, self.rot_matrix.transpose())
-
-        for mat in self.vert_buffer:
-            # Handle vertex buffer
-            glBindBuffer(GL_ARRAY_BUFFER, self.vert_buffer[mat])
-            glEnableVertexAttribArray(0)
-            glVertexAttribPointer(0, self.vertex_dim[mat], GL_DOUBLE, GL_FALSE, 0, None)
-
-            # Handle normal buffer
-            glBindBuffer(GL_ARRAY_BUFFER, self.norm_buffer[mat])
-            glEnableVertexAttribArray(1)
-            glVertexAttribPointer(1, 3, GL_DOUBLE, GL_FALSE, 0, None)
-
-            # Handle uv buffer
-            glBindBuffer(GL_ARRAY_BUFFER, self.uv_buffer[mat])
-            glEnableVertexAttribArray(2)
-            glVertexAttribPointer(2, 2, GL_DOUBLE, GL_FALSE, 0, None)
-
-            # Handle tan buffer
-            glBindBuffer(GL_ARRAY_BUFFER, self.tan_buffer[mat])
-            glEnableVertexAttribArray(3)
-            glVertexAttribPointer(3, 3, GL_DOUBLE, GL_FALSE, 0, None)
-
-            # Handle btan buffer
-            glBindBuffer(GL_ARRAY_BUFFER, self.btan_buffer[mat])
-            glEnableVertexAttribArray(4)
-            glVertexAttribPointer(4, 3, GL_DOUBLE, GL_FALSE, 0, None)
-
-            # Handle PTR buffer
-            glBindBuffer(GL_ARRAY_BUFFER, self.prt1_buffer[mat])
-            glEnableVertexAttribArray(5)
-            glVertexAttribPointer(5, 3, GL_DOUBLE, GL_FALSE, 0, None)
-
-            glBindBuffer(GL_ARRAY_BUFFER, self.prt2_buffer[mat])
-            glEnableVertexAttribArray(6)
-            glVertexAttribPointer(6, 3, GL_DOUBLE, GL_FALSE, 0, None)
-
-            glBindBuffer(GL_ARRAY_BUFFER, self.prt3_buffer[mat])
-            glEnableVertexAttribArray(7)
-            glVertexAttribPointer(7, 3, GL_DOUBLE, GL_FALSE, 0, None)
-
-            for i, smplr in enumerate(self.render_texture_mat[mat]):
-                glActiveTexture(GL_TEXTURE0 + i)
-                glBindTexture(GL_TEXTURE_2D, self.render_texture_mat[mat][smplr])
-                glUniform1i(glGetUniformLocation(self.program, smplr), i)
-
-            glDrawArrays(GL_TRIANGLES, 0, self.n_vertices[mat])
-
-            glDisableVertexAttribArray(7)
-            glDisableVertexAttribArray(6)
-            glDisableVertexAttribArray(5)
-            glDisableVertexAttribArray(4)
-            glDisableVertexAttribArray(3)
-            glDisableVertexAttribArray(2)
-            glDisableVertexAttribArray(1)
-            glDisableVertexAttribArray(0)
-
-        glBindBuffer(GL_ARRAY_BUFFER, 0)
-
-        glUseProgram(0)
-
-        glDisable(GL_BLEND)
-        glDisable(GL_MULTISAMPLE)
-
-        self.draw_end()
diff --git a/spaces/etri-vilab/Ko-LLaVA/static/css/styles.css b/spaces/etri-vilab/Ko-LLaVA/static/css/styles.css
deleted file mode 100644
index 560dfcde21b0fcd93dfad0bf6e77d0faf12c5b53..0000000000000000000000000000000000000000
--- a/spaces/etri-vilab/Ko-LLaVA/static/css/styles.css
+++ /dev/null
@@ -1,215 +0,0 @@
-#avatar-video, #talking-vid {
-    justify-content: center;
-    align-items: center;
-    display: flex;
-    height: 320px;
-    margin-top: 12px;
-}
-video { 
-  border-top-right-radius: 3rem;
-  border-top-left-radius: 3rem;
-  width: 100%;
-  margin-bottom: 20px;
-  margin-top: 120px;
-  z-index: -1;
-}
-.btn {
-    border-radius: 1.5rem !important;
-    z-index: 2;
-    /* background-color: #9e9e9e !important; */
-    border:none;
-}
-
-.iceConnectionState-connected, 
-.iceConnectionState-completed,
-.peerConnectionState-connected,
-#ice-gathering-status-label,
-.ice-status-label,
-.signalingState-stable,
-.streamingState-empty {
-    color: green;
-}
-#video-select {
-    box-shadow: 0 0 2rem rgba(0,0,0,.14)!important;
-    border-radius: 0.7rem;
-    padding: 12px;
-    text-align: end !important;
-}
-.video-select {
-   position: absolute;
-   padding-top: 5px;
-}
-
-#user-text {
-    position: absolute;
-    width: 100%;
-    z-index: 1;
-    box-shadow: 0 0 2rem rgba(0,0,0,.14)!important;
-    border-radius: 1.5rem;
-    border: 1px;
-}
-#chat-window {
-    box-shadow: 0 0 2rem rgba(0,0,0,.14)!important;
-    border: none;
-    border-radius: 1.5rem;
-}
-.col-md-12 {
-    box-shadow: 0 0 2rem rgba(0,0,0,.14)!important;
-    border-radius: 3rem;
-    padding: 20px;
-    padding-bottom: 80px;
-    width: 750px;
-    /* width: 485px; */
-}
-.input-group-append {
-    right: 10px;
-    position: absolute;
-    z-index: 2;
-}
-
-.input-group-append {
-  transition: width 0.8s ease-in-out;
-  border-radius: 1.5rem !important;
-}
-
-.expanded {
-  width: 100%;
-  background-image: url('./images/record_waveform.gif');
-  background-position: center;
-  height: 59px;
-  top: 2px;
-  left: 0px;
-  text-align: end;
-  cursor: pointer;
-}
-
-.expanded button {
-  margin-top: -3px;
-  margin-right: 3px;
-}
-
-
-.btn-secondary {
-  background-color: #198754 !important;
-}
-.input-group .btn {
-    position: relative;
-    z-index: 2;
-    width: 50px;
-    border-radius: 8px !important;
-}
-#info {
-    text-align: center !important;
-    border-radius: 3rem;
-    font-size: 14px;
-}
-#info a {
-    color: darkred;
-    text-decoration: underline;
-  }
-  
-  .final {
-    color: black;
-    padding-right: 3px; 
-  }
-  .interim {
-    color: gray;
-  }
-  .select-avatar {
-    margin-top: 130px !important;
-  }
-  #results {
-    font-size: 14px;
-    font-weight: bold;
-    border: 1.4px solid #ddd;
-    padding: 15px;
-    text-align: left;
-    overflow-y: scroll;
-    height: 400px;
-    margin: 0 0 20px 0;
-    border-radius: 0.7rem;
-  }
-  /* #llasaLoading {
-    font-size: 14px;
-    font-weight: bold;
-    border: 1.4px solid #ddd;
-    padding: 15px;
-    text-align: left;
-    overflow-y: scroll;
-    height: 400px;
-    margin: 0 0 20px 0;
-    border-radius: 0.7rem;
-    justify-content: center;
-  } */
-  .btn-success {
-    background: #9e9e9e !important;
-  }
-
-  .sent-message {
-    margin-left: 37px !important;
-  }
-  #start_button {
-    border: 0;
-    background-color:transparent;
-    padding: 0;
-    cursor: pointer;
-  }
-  #delete_button {
-    border: 0;
-    background-color:transparent;
-    padding: 0;
-    cursor: pointer;
-  }
-  .small {
-    background-color: #d1e7dd !important;
-    font-size: 14px;
-    color: black !important;
-    width: fit-content;
-  }
-  .time {
-    text-align: center !important;
-  }
-  #start_img, #delete_img, #send_text_img {
-    width: 30px;
-    height: 30px;
-  }
-  #send_button {
-    border: 0;
-    background-color: transparent;
-    padding: 0;
-  }
-  #status {
-    font-size: 8px;
-    color: #cacecccc;
-  }
-  
-  .btn-primary, .btn-danger {
-    width: 100px;
-    margin: auto;
-  }
-  .alert {
-    padding:0.5rem !important ;
-  }
-  select {
-    padding: 5px 5px;
-  }
-  #select_dialect {
-    width: 80px;
-  }
-  #select_language {
-    width: 60px
-  }
-  @media screen and (max-width: 767px) {
-      #select_dialect {
-        position: absolute;
-        right: 0;
-      } 
-  }
-  
-  @media screen and (min-width: 768px) {
-    select {
-      margin-right: 10px;
-    }
-  }
-
-  
\ No newline at end of file
diff --git a/spaces/fabiochiu/title-generation/README.md b/spaces/fabiochiu/title-generation/README.md
deleted file mode 100644
index e1c223132051379a650ecee91a92d3babb07592a..0000000000000000000000000000000000000000
--- a/spaces/fabiochiu/title-generation/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Title Generation
-emoji: 📈
-colorFrom: purple
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.2.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/falcondai/code-as-policies/prompts/parse_obj_name.py b/spaces/falcondai/code-as-policies/prompts/parse_obj_name.py
deleted file mode 100644
index 536be8ab1e6c1f473b4e592da23f3b4951627080..0000000000000000000000000000000000000000
--- a/spaces/falcondai/code-as-policies/prompts/parse_obj_name.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import numpy as np
-from env_utils import get_obj_pos, parse_position
-from utils import get_obj_positions_np
-
-objects = ['blue block', 'cyan block', 'purple bowl', 'gray bowl', 'brown bowl', 'pink block', 'purple block']
-# the block closest to the purple bowl.
-block_names = ['blue block', 'cyan block', 'purple block']
-closest_block_idx = get_closest_idx(points=get_obj_positions_np(block_names), point=get_obj_pos('purple bowl'))
-closest_block_name = block_names[closest_block_idx]
-ret_val = closest_block_name
-objects = ['brown bowl', 'banana', 'brown block', 'apple', 'blue bowl', 'blue block']
-# the blocks.
-ret_val = ['brown block', 'blue block']
-objects = ['brown bowl', 'banana', 'brown block', 'apple', 'blue bowl', 'blue block']
-# the brown objects.
-ret_val = ['brown bowl', 'brown block']
-objects = ['brown bowl', 'banana', 'brown block', 'apple', 'blue bowl', 'blue block']
-# a fruit that's not the apple
-fruit_names = ['banana', 'apple']
-for fruit_name in fruit_names:
-    if fruit_name != 'apple':
-        ret_val = fruit_name
-objects = ['blue block', 'cyan block', 'purple bowl', 'brown bowl', 'purple block']
-# blocks above the brown bowl.
-block_names = ['blue block', 'cyan block', 'purple block']
-brown_bowl_pos = get_obj_pos('brown bowl')
-use_block_names = []
-for block_name in block_names:
-    if get_obj_pos(block_name)[1] > brown_bowl_pos[1]:
-        use_block_names.append(block_name)
-ret_val = use_block_names
-objects = ['blue block', 'cyan block', 'purple bowl', 'brown bowl', 'purple block']
-# the blue block.
-ret_val = 'blue block'
-objects = ['blue block', 'cyan block', 'purple bowl', 'brown bowl', 'purple block']
-# the block closest to the bottom right corner.
-corner_pos = parse_position('bottom right corner')
-block_names = ['blue block', 'cyan block', 'purple block']
-closest_block_idx = get_closest_idx(points=get_obj_positions_np(block_names), point=corner_pos)
-closest_block_name = block_names[closest_block_idx]
-ret_val = closest_block_name
-objects = ['brown bowl', 'green block', 'brown block', 'green bowl', 'blue bowl', 'blue block']
-# the left most block.
-block_names = ['green block', 'brown block', 'blue block']
-left_block_idx = np.argsort(get_obj_positions_np(block_names)[:, 0])[0]
-left_block_name = block_names[left_block_idx]
-ret_val = left_block_name
-objects = ['brown bowl', 'green block', 'brown block', 'green bowl', 'blue bowl', 'blue block']
-# the bowl on near the top.
-bowl_names = ['brown bowl', 'green bowl', 'blue bowl']
-top_bowl_idx = np.argsort(get_obj_positions_np(bowl_names)[:, 1])[-1]
-top_bowl_name = bowl_names[top_bowl_idx]
-ret_val = top_bowl_name
-objects = ['yellow bowl', 'purple block', 'yellow block', 'purple bowl', 'pink bowl', 'pink block']
-# the third bowl from the right.
-bowl_names = ['yellow bowl', 'purple bowl', 'pink bowl']
-bowl_idx = np.argsort(get_obj_positions_np(bowl_names)[:, 0])[-3]
-bowl_name = bowl_names[bowl_idx]
-ret_val = bowl_name
\ No newline at end of file
diff --git a/spaces/falcondai/code-as-policies/prompts/parse_question.py b/spaces/falcondai/code-as-policies/prompts/parse_question.py
deleted file mode 100644
index bbc2332dc1dd7ef924adcd3608accf63a2c1db02..0000000000000000000000000000000000000000
--- a/spaces/falcondai/code-as-policies/prompts/parse_question.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from utils import get_obj_pos, get_obj_names, parse_obj_name, bbox_contains_pt, is_obj_visible
-
-objects = ['yellow bowl', 'blue block', 'yellow block', 'blue bowl', 'fruit', 'green block', 'black bowl']
-# is the blue block to the right of the yellow bowl?
-ret_val = get_obj_pos('blue block')[0] > get_obj_pos('yellow bowl')[0]
-objects = ['yellow bowl', 'blue block', 'yellow block', 'blue bowl', 'fruit', 'green block', 'black bowl']
-# how many yellow objects are there?
-yellow_object_names = parse_obj_name('the yellow objects', f'objects = {get_obj_names()}')
-ret_val = len(yellow_object_names)
-objects = ['pink block', 'green block', 'pink bowl', 'blue block', 'blue bowl', 'green bowl']
-# what are the blocks left of the green bowl?
-block_names = parse_obj_name('the blocks', f'objects = {get_obj_names()}')
-green_bowl_pos = get_obj_pos('green bowl')
-left_block_names = []
-for block_name in block_names:
-  if get_obj_pos(block_name)[0] < green_bowl_pos[0]:
-    left_block_names.append(block_name)
-ret_val = left_block_names
-objects = ['pink block', 'yellow block', 'pink bowl', 'blue block', 'blue bowl', 'yellow bowl']
-# is the sun colored block above the blue bowl?
-sun_block_name = parse_obj_name('sun colored block', f'objects = {get_obj_names()}')
-sun_block_pos = get_obj_pos(sun_block_name)
-blue_bowl_pos = get_obj_pos('blue bowl')
-ret_val = sun_block_pos[1] > blue_bowl_pos[1]
-objects = ['pink block', 'yellow block', 'pink bowl', 'blue block', 'blue bowl', 'yellow bowl']
-# is the green block below the blue bowl?
-ret_val = get_obj_pos('green block')[1] < get_obj_pos('blue bowl')[1]
\ No newline at end of file
diff --git a/spaces/falterWliame/Face_Mask_Detection/Download Sp5 Solidworks 2012 Crackl UPDATED.md b/spaces/falterWliame/Face_Mask_Detection/Download Sp5 Solidworks 2012 Crackl UPDATED.md
deleted file mode 100644
index 33054f0442dd3fcd79b58623d875f18ed1db3945..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/Download Sp5 Solidworks 2012 Crackl UPDATED.md	
+++ /dev/null
@@ -1,44 +0,0 @@
-<h2>Download Sp5 Solidworks 2012 Crackl</h2><br /><p><b><b>Download</b> &rarr; <a href="https://urlca.com/2uDdNQ">https://urlca.com/2uDdNQ</a></b></p><br /><br />
-
-After Microsoft released this update, SOLIDWORKS has released a patch for their bug " Initial loading of objects with large proportions in a solid model will cause an out of memory error. 
-
-See also
-
-SolidWorks (software)
-
-List of Product Design and Management programs
-
-References
-
-External links
-
-Software
-
-Category:Computer-aided design software for Windows
-
-Category:Computer-aided design software for MacOS
-
-Category:1996 software
-
-Category:Computer-aided engineering software
-
-Category:Computer-aided design software for Linux is the same way, they could have worked on Earth then moved to Mars, but they didn’t. They only worked on Mars. So the changes you are seeing right now are based on the fact that humans went from Earth to Mars, and then through various generations, to where they are now. And that’s the reason why things are so different on Mars right now, than they were on Earth. They had a different process going. They didn’t go from there to here, but rather from here to Mars.
-
-As a result, the crew on Mars have evolved and evolved. And they are very different from what they would have been on Earth. So the changes that you are seeing today are based on the fact that this evolution has happened.
-
-What would you say the biggest misconception is that people have about Mars?
-
-I think the biggest misconception is the notion that a human on Mars is something that is going to happen in the future. It’s already happening. We have people living on Mars now.
-
-Sure, we know there are limitations with the technology, but there are challenges that have already been overcome. And there are more challenges that are coming up that are being addressed.
-
-And the first generation to go to Mars isn’t going to live there. They’ll be a tourist class type of thing. The next generation is going to be more like a permanent settlement.
-
-You mentioned in your book that people think the changes in Mars are happening relatively quickly. But in reality, they are happening on a geological time scale. How do you explain that to people?
-
-What you are seeing is a result of what we call a soft landing, when you’re on the surface of a planet. It’s like landing on the surface of a beach. You hit the ground, and you sink in.
-
-You are going to 4fefd39f24<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/fatiXbelha/sd/Download AI Dawn and Create Amazing Avatars with One Click.md b/spaces/fatiXbelha/sd/Download AI Dawn and Create Amazing Avatars with One Click.md
deleted file mode 100644
index 27e705df94e0fc08e1085e2ea3688e5b3ba77746..0000000000000000000000000000000000000000
--- a/spaces/fatiXbelha/sd/Download AI Dawn and Create Amazing Avatars with One Click.md	
+++ /dev/null
@@ -1,110 +0,0 @@
-<br />
-<h1>Download AI Dawn: How to Create Amazing Avatars with Artificial Intelligence</h1>
- <p>Have you ever wondered what you would look like as a cartoon character, a classical painting, or a 3D render? Do you want to impress your friends and followers with unique and fun images of yourself and your pets? If you answered yes, then you should try AI Dawn, a new app that lets you create outstanding avatars using the latest AI technology. In this article, we will show you what AI Dawn is, how it works, how to download it on your device, and how to use it to create stunning avatars. We will also share some tips and tricks to get the most out of this app. Let's get started!</p>
-<h2>download ai dawn</h2><br /><p><b><b>Download File</b> >>> <a href="https://urllie.com/2uNxv3">https://urllie.com/2uNxv3</a></b></p><br /><br />
- <h2>What is AI Dawn?</h2>
- <h3>A brief introduction to the app and its features</h3>
- <p>AI Dawn is an app that allows you to create selfies, portraits, and headshots with the power of AI. You can upload your photos and let AI Dawn work its magic—showing you and your friends in an incredible mix of styles and settings. And all at the click of a button.</p>
- <p>With AI Dawn's innovative technology, you can surprise your friends with content that's never been seen before. The app's AI analyzes your photos to learn what you look like, then produces stunning portraits with thousands of possible styles. You can see yourself sketched in black and white or painted in vibrant color. You can browse your own AI-generated selfies, styled as hyperrealistic photos, classical art, and more. You can also try theme packs and purchase sets of images by style. You can pick the packs that suit your personality, then sit back and relax while the app's AI generator gets to work. You can then share the results with your friends—and the world!</p>
- <h3>How does AI Dawn work?</h3>
- <p>AI Dawn uses a combination of deep learning and generative adversarial networks (GANs) to create realistic and artistic images from your photos. GANs are a type of neural network that consists of two parts: a generator and a discriminator. The generator tries to create fake images that look like real ones, while the discriminator tries to tell them apart. The generator learns from its mistakes and improves over time, producing more convincing images.</p>
- <p>AI Dawn's generator uses a large database of images from various sources, such as paintings, cartoons, anime, etc., to learn different styles and features. It then applies these styles and features to your photos, creating new images that resemble you but also have a distinct artistic flair. The discriminator ensures that the generated images are realistic and consistent with the original photos.</p>
- <h3>What are the benefits of using AI Dawn?</h3>
- <p>Using AI Dawn has many benefits, such as:</p>
-<ul>
-<li>You can have fun creating unique and original content with AI.</li>
-<li>You can explore endless styles and settings for your avatars.</li>
-<li>You can generate funny portraits of your friends and pets.</li>
-<li>You can experience the power of AI and see yourself in landscapes that are out of this world.</li>
-<li>You can create portraits with cutting-edge AI technology.</li>
-<li>You can stand out on social media with entirely unique visuals.</li>
-</ul>
- <h2>How to download AI Dawn on your device</h2>
- <h3>For Android users</h3>
- <p>If you have an Android device, you can download AI Dawn from Google Play Store for free. Here are the steps:</p>
-<ol>
-<li>Open Google Play Store on your device.</li>
-<li>Search for "AI Dawn" or use this link: <a href="https://play.google.com/store/apps/details?id=com.aidawn.app">https://play.google.com/store/apps/details?id=com.aidawn.app</a></li>
-<li>Tap on the "Install" button and wait for the app to download and install on your device.</li>
-<li>Once the app is installed, you can open it and start creating your avatars.</li>
-</ol>
- <h3>For PC users</h3>
- <p>If you want to use AI Dawn on your PC, you will need an Android emulator that can run Android apps on your computer. There are many emulators available, such as BlueStacks, NoxPlayer, MEmu, etc. You can choose the one that suits your preferences and system requirements. Here are the general steps:</p>
-<ol>
-<li>Download and install an Android emulator of your choice on your PC.</li>
-<li>Launch the emulator and sign in with your Google account.</li>
-<li>Open Google Play Store on the emulator and search for "AI Dawn" or use this link: <a href="https://play.google.com/store/apps/details?id=com.aidawn.app">https://play.google.com/store/apps/details?id=com.aidawn.app</a></li>
-<li>Install the app and wait for it to appear on the emulator's home screen.</li>
-<li>Open the app and start creating your avatars.</li>
-</ol>
- <h2>How to use AI Dawn to create stunning avatars</h2>
- <h3>Step 1: Upload your photo or choose from the gallery</h3>
- <p>The first step to create your avatar is to upload your photo or choose one from the app's gallery. You can use any photo of yourself or anyone else, as long as it is clear and shows the face well. You can also use photos of animals, such as cats, dogs, birds, etc. To upload your photo, tap on the "+" icon on the bottom right corner of the screen. You can then select a photo from your device's gallery or take a new one with your camera. To choose a photo from the app's gallery, tap on the "Gallery" icon on the bottom left corner of the screen. You can then browse through various categories of photos, such as celebrities, animals, cartoons, etc. Tap on the photo you want to use and it will be loaded into the app.</p>
- <h3>Step 2: Select a style or theme pack</h3>
- <p>The next step is to select a style or theme pack for your avatar. A style is a single image that shows how your avatar will look like, while a theme pack is a set of images that share a common style. You can choose from hundreds of styles and theme packs available in the app, ranging from realistic to artistic, from modern to vintage, from cute to scary, and more. To select a style or theme pack, tap on the "Style" icon on the bottom center of the screen. You can then scroll through various options and tap on the one you like. You can also use the search bar to find a specific style or theme pack by name or keyword.</p>
-<p>Download Dawn AI - Avatar Generator app<br />
-How to create outstanding avatars with Dawn AI<br />
-Dawn AI art: how to generate images from text or photos<br />
-The best AI image generator apps: Dawn AI vs Lensa AI vs Meitu AI<br />
-Dawn AI review: pros and cons of the AI avatar creator<br />
-How to use Dawn AI to create unique content for social media<br />
-Dawn AI alternatives: other apps that use AI to generate art<br />
-How to edit and customize your avatars with Dawn AI<br />
-The future of AI art: what Dawn AI can do and what's next<br />
-How to download and install Dawn AI on your device<br />
-How to get free theme packs and images with Dawn AI<br />
-How to share your creations from Dawn AI on Instagram, TikTok, Snapchat, etc.<br />
-How to delete your data from Dawn AI and protect your privacy<br />
-How to contact Dawn AI support and give feedback<br />
-How to troubleshoot common issues with Dawn AI<br />
-How to use Dawn AI for education and learning purposes<br />
-How to create funny portraits of your friends and pets with Dawn AI<br />
-How to see yourself in different styles and settings with Dawn AI<br />
-How to compare your avatars with classical art and hyperrealism with Dawn AI<br />
-How to create 3D render, fine art, pen sketch, anime, impressionism, and more with Dawn AI<br />
-Download Stanford DAWN: a research project to democratize AI<br />
-How to build AI-powered applications with Stanford DAWN<br />
-Stanford DAWN review: the benefits and challenges of the project<br />
-Stanford DAWN alternatives: other research projects and platforms that aim to democratize AI<br />
-How to join Stanford DAWN and contribute to the project<br />
-How to use Stanford DAWN for data analysis, machine learning, deep learning, etc.<br />
-How to access the resources and publications of Stanford DAWN<br />
-How to contact Stanford DAWN team and give feedback<br />
-How to troubleshoot common issues with Stanford DAWN<br />
-How to use Stanford DAWN for education and learning purposes<br />
-Download The dawn of AI has come article by The Conversation<br />
-How to read and understand The dawn of AI has come article by The Conversation<br />
-The dawn of AI has come article review: the main points and arguments of the article<br />
-The dawn of AI has come article alternatives: other articles and sources that discuss the implications of AI for education<br />
-How to cite The dawn of AI has come article by The Conversation in your academic work<br />
-How to share The dawn of AI has come article by The Conversation on social media or email<br />
-How to comment on The dawn of AI has come article by The Conversation and join the discussion<br />
-How to contact The dawn of AI has come article author and give feedback<br />
-How to subscribe to The Conversation and get more articles on AI and education topics<br />
-How to use The dawn of AI has come article by The Conversation for education and learning purposes</p>
- <h3>Step 3: Adjust the settings and preview the result</h3>
- <p>The third step is to adjust the settings and preview the result of your avatar. You can customize various aspects of your avatar, such as brightness, contrast, saturation, hue, sharpness, etc. You can also apply filters, stickers, frames, text, and other effects to enhance your avatar. To adjust the settings, tap on the "Settings" icon on the top right corner of the screen. You can then use the sliders and buttons to change different parameters and see how they affect your avatar. To preview the result, tap on the "Preview" icon on the top left corner of the screen. You can then see how your avatar looks like in full size and quality.</p>
- <h3>Step 4: Save and share your avatar</h3>
- <p>The final step is to save and share your avatar with others. You can save your avatar to your device's gallery or share it directly to social media platforms, such as Facebook, Instagram, Twitter, WhatsApp, etc. To save your avatar, tap on the "Save" icon on the top right corner of the screen. You can then choose a file format (JPG or PNG) and a file size (Small, Medium, Large, or Original). To share your avatar, tap on the "Share" icon on the top left corner of the screen. You can then choose a platform and a contact to send your avatar to.</p>
- <h2>Tips and tricks to get the most out of AI Dawn</h2>
- <h3>Experiment with different styles and settings</h3>
- <p>One of the best ways to enjoy AI Dawn is to experiment with different styles and settings for your avatars. You can try different combinations of styles and settings and see how they change the appearance and mood of your avatars. You can also compare different styles and settings and choose the ones that suit your preferences and goals. You can also mix and match different styles and settings to create unique and original avatars that no one else has.</p>
- <h3>Use high-quality photos for better results</h3>
- <p>Another tip to get the most out of AI Dawn is to use high-quality photos for your avatars. The app's AI works best when the photos are clear, bright, and show the face well. If the photos are blurry, dark, or have other issues, the app may not be able to generate good results. Therefore, it is recommended to use photos that have good resolution, lighting, and focus. You can also use the app's settings to adjust the brightness, contrast, and other parameters of your photos to improve their quality.</p>
- <h3>Have fun and be creative</h3>
- <p>The most important tip to enjoy AI Dawn is to have fun and be creative with your avatars. The app is designed to let you explore your imagination and express yourself in new ways. You can create avatars that reflect your personality, mood, interests, hobbies, etc. You can also create avatars that are funny, surprising, or even bizarre. You can use the app as a tool to entertain yourself and others, or as a way to discover new aspects of yourself and the world. The possibilities are endless with AI Dawn!</p>
- <h2>Conclusion</h2>
- <p>AI Dawn is an amazing app that lets you create stunning avatars with artificial intelligence. You can upload your photos and see yourself in a variety of styles and settings, from realistic to artistic, from modern to vintage, from cute to scary, and more. You can also customize your avatars with various settings and effects, and share them with your friends and followers on social media. AI Dawn is easy to use, fun to play with, and impressive to look at. If you want to experience the power of AI and create amazing avatars, download AI Dawn today!</p>
- <h2>FAQs</h2>
- <h4>Q: Is AI Dawn free?</h4>
-<p>A: Yes, AI Dawn is free to download and use. However, some styles and theme packs may require in-app purchases or subscriptions.</p>
- <h4>Q: Is AI Dawn safe?</h4>
-<p>A: Yes, AI Dawn is safe to use. The app does not collect or store any personal information from your photos or device. The app also does not share or sell any data to third parties.</p>
- <h4>Q: How can I contact AI Dawn?</h4>
-<p>A: If you have any questions, feedback, or suggestions for AI Dawn, you can contact the app's developers by email at support@aidawn.com or by visiting their website at https://www.aidawn.com/.</p>
- <h4>Q: What are some similar apps to AI Dawn?</h4>
-<p>A: Some similar apps to AI Dawn are FaceApp, Prisma Photo Editor, ToonMe Cartoon Photo Editor, etc.</p>
- <h4>Q: Can I use AI Dawn for commercial purposes?</h4>
-<p>A: No, AI Dawn is intended for personal and non-commercial use only. You cannot use the app's generated images for any commercial purposes without obtaining prior permission from the app's developers.</p> 197e85843d<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/fatiXbelha/sd/Experience Minecraft Like Never Before with Mini Block Craft Mod Menu APK.md b/spaces/fatiXbelha/sd/Experience Minecraft Like Never Before with Mini Block Craft Mod Menu APK.md
deleted file mode 100644
index 2555abdc036f376a4d10ac83cebc12236c6a160d..0000000000000000000000000000000000000000
--- a/spaces/fatiXbelha/sd/Experience Minecraft Like Never Before with Mini Block Craft Mod Menu APK.md	
+++ /dev/null
@@ -1,127 +0,0 @@
-<br />
-<h1>Mini Block Craft Mod Menu APK: A Guide for Beginners</h1>
-<p>If you are a fan of sandbox games, you might have heard of Mini Block Craft, a popular game that lets you create your own world with blocks. But did you know that there is a modded version of this game that gives you more features and options? In this article, we will tell you everything you need to know about Mini Block Craft Mod Menu APK, a modified version of the game that lets you enjoy unlimited money, free craft, and more. Read on to find out how to download, install, and use this amazing mod.</p>
- <h2>What is Mini Block Craft?</h2>
-<p>Mini Block Craft is a game developed by Build Block Studio, which is available for Android devices. It is a sandbox game that allows you to create your own world with blocks. You can build houses, castles, farms, cities, and anything else you can imagine. You can also explore other players' worlds and interact with them. The game has pixel graphics and simple controls, making it easy and fun to play.</p>
-<h2>mini block craft mod menu apk</h2><br /><p><b><b>DOWNLOAD</b> &#8230;&#8230;&#8230; <a href="https://urllie.com/2uNzRj">https://urllie.com/2uNzRj</a></b></p><br /><br />
- <h3>Features of Mini Block Craft</h3>
-<p>Some of the features of Mini Block Craft are:</p>
-<ul>
-<li>You can create your own world with blocks of different shapes, colors, and materials.</li>
-<li>You can explore other players' worlds and chat with them.</li>
-<li>You can collect resources and craft items such as tools, weapons, armor, and furniture.</li>
-<li>You can breed animals and grow crops.</li>
-<li>You can customize your character's appearance and clothes.</li>
-<li>You can play offline or online with friends.</li>
-</ul>
- <h3>How to play Mini Block Craft</h3>
-<p>To play Mini Block Craft, you need to download and install the game from the Google Play Store or from other sources. Once you launch the game, you can choose to create a new world or join an existing one. You can also choose the mode of the game: creative or survival. In creative mode, you have unlimited resources and can build anything you want. In survival mode, you have to gather resources, craft items, and fight enemies. You can also switch between modes anytime.</p>
- <h2>What is Mini Block Craft Mod Menu APK?</h2>
-<p>Mini Block Craft Mod Menu APK is a modified version of Mini Block Craft developed by unknown modders. The difference between the mod version and the original version is that the mod version has a menu that lets you access various cheats and hacks. For example, you can get unlimited money, free craft, no ads, and more. The mod version also has some extra features that are not available in the original version.</p>
- <h3>Benefits of Mini Block Craft Mod Menu APK</h3>
-<p>Some of the benefits of Mini Block Craft Mod Menu APK are:</p>
-<ul>
-<li>You can get unlimited money and free craft, which means you can buy and build anything you want without any limitations.</li>
-<li>You can remove ads from the game, which means you can enjoy a smoother and more immersive gaming experience.</li>
-<li>You can unlock all the items and skins in the game, which means you can customize your character and items as you wish.</li>
-<li>You can access other cheats and hacks from the menu, such as speed hack, fly hack, god mode, etc.</li>
-<li>You can enjoy some extra features that are not available in the original version, such as night mode, weather mode, etc.</li>
-</ul>
- <h3>How to download and install Mini Block Craft Mod Menu APK</h3>
-<p>To download and install Mini Block Craft Mod Menu APK, you need to follow these steps:</ <p>- First, you need to download the Mini Block Craft Mod Menu APK file from a reliable source. You can search for it on the internet or use the link below. Make sure you have enough storage space on your device before downloading the file.</p>
-<p>- Next, you need to enable the installation of apps from unknown sources on your device. To do this, go to Settings > Security > Unknown Sources and toggle it on. This will allow you to install the modded version of the game.</p>
-<p>- Then, you need to locate the downloaded APK file on your device and tap on it to start the installation process. Follow the instructions on the screen and wait for the installation to complete.</p>
-<p>mini block craft mod menu apk download<br />
-mini block craft mod menu apk free<br />
-mini block craft mod menu apk unlimited money<br />
-mini block craft mod menu apk latest version<br />
-mini block craft mod menu apk happymod<br />
-mini block craft mod menu apk android 1<br />
-mini block craft mod menu apk 2021<br />
-mini block craft mod menu apk 6.5.2<br />
-mini block craft mod menu apk no root<br />
-mini block craft mod menu apk offline<br />
-mini block craft mod menu apk for pc<br />
-mini block craft mod menu apk rexdl<br />
-mini block craft mod menu apk revdl<br />
-mini block craft mod menu apk pure<br />
-mini block craft mod menu apk uptodown<br />
-mini block craft mod menu apk an1<br />
-mini block craft mod menu apk mediafıre<br />
-mini block craft mod menu apk mega<br />
-mini block craft mod menu apk 55.5.2<br />
-mini block craft mod menu apk 6.5.4<br />
-mini block craft mod menu apk 6.5.3<br />
-mini block craft mod menu apk 6.5.5<br />
-mini block craft mod menu apk 6.5.6<br />
-mini block craft mod menu apk 6.5.7<br />
-mini block craft mod menu apk 6.5.8<br />
-mini block craft mod menu apk 6.5.9<br />
-mini block craft mod menu apk 6.5.10<br />
-mini block craft mod menu apk 6.5.11<br />
-mini block craft mod menu apk 6.5.12<br />
-mini block craft mod menu apk 6.5.13<br />
-mini block craft mod menu apk 6.5.14<br />
-mini block craft mod menu apk 6.5.15<br />
-mini block craft mod menu apk 6.5.16<br />
-mini block craft mod menu apk 6.5.17<br />
-mini block craft mod menu apk 6.5.18<br />
-mini block craft mod menu apk 6.5.19<br />
-mini block craft mod menu apk 6.5.20<br />
-mini block craft mod menu apk hack<br />
-mini block craft mod menu apk cheat<br />
-mini block craft mod menu apk premium</p>
-<p>- Finally, you need to launch the game and enjoy the mod menu. You can access the menu by tapping on the icon on the top left corner of the screen. From there, you can enable or disable any cheat or hack you want.</p>
- <h3>How to use Mini Block Craft Mod Menu APK</h3>
-<p>To use Mini Block Craft Mod Menu APK, you need to follow these steps:</p>
-<p>- First, you need to create a new world or join an existing one. You can choose the mode of the game: creative or survival. You can also switch between modes anytime.</p>
-<p>- Next, you need to access the mod menu by tapping on the icon on the top left corner of the screen. From there, you can enable or disable any cheat or hack you want.</p>
-<p>- Some of the cheats and hacks you can use are:</p>
-<ul>
-<li>Unlimited money: This will give you unlimited money in the game, which you can use to buy and build anything you want.</li>
-<li>Free craft: This will allow you to craft any item without using any resources.</li>
-<li>No ads: This will remove ads from the game, which will make your gaming experience smoother and more immersive.</li>
-<li>All items unlocked: This will unlock all the items and skins in the game, which you can use to customize your character and items.</li>
-<li>Speed hack: This will increase your speed in the game, which will help you move faster and explore more.</li>
-<li>Fly hack: This will enable you to fly in the game, which will help you reach higher places and avoid obstacles.</li>
-<li>God mode: This will make you invincible in the game, which will protect you from any damage and enemies.</li>
-<li>Night mode: This will change the time of day in the game, which will make it darker and more challenging.</li>
-<li>Weather mode: This will change the weather in the game, which will make it more realistic and diverse.</li>
-</ul>
- <h2>Tips and tricks for Mini Block Craft Mod Menu APK</h2>
-<p>Here are some tips and tricks for Mini Block Craft Mod Menu APK that will help you enjoy the game more:</p>
- <h3>How to get unlimited money and free craft</h3>
-<p>To get unlimited money and free craft in Mini Block Craft Mod Menu APK, you need to enable these cheats from the mod menu. Once you do that, you can buy and build anything you want without any limitations. You can also craft any item without using any resources. This will help you create your own world with blocks easily and quickly.</p>
- <h3>How to build your own world and explore others' worlds</h3>
-<p>To build your own world in Mini Block Craft Mod Menu APK, you need to use blocks of different shapes, colors, and materials. You can find blocks in your inventory or craft them with resources. You can also buy blocks with money. To place a block, tap on the screen where you want to put it. To remove a block, tap and hold on it until it disappears. You can also rotate and move blocks by swiping on them. To build your own world, you can use your imagination and creativity. You can build houses, castles, farms, cities, and anything else you can think of. You can also decorate your world with items such as furniture, plants, animals, etc.</p>
- <p>To explore others' worlds in Mini Block Craft Mod Menu APK, you need to join an online server or create your own server. You can find servers in the multiplayer menu or create your own server by tapping on the plus icon. Once you join a server, you can see other players' worlds and chat with them. You can also visit their worlds and interact with them. You can also invite your friends to join your server and play together.</p>
- <h3>How to customize your character and items</h3>
-<p>To customize your character in Mini Block Craft Mod Menu APK, you need to tap on the character icon on the top right corner of the screen. From there, you can change your character's appearance and clothes. You can choose from different skins, hair styles, eyes, mouths, noses, etc. You can also buy more skins with money. To change your clothes, you can choose from different outfits, hats, shoes, etc. You can also buy more clothes with money.</p>
- <p>To customize your items in Mini Block Craft Mod Menu APK, you need to tap on the item icon on the top right corner of the screen. From there, you can see all the items you have in your inventory or craft them with resources. You can also buy items with money. To use an item, tap on it and then tap on the screen where you want to use it. To customize an item, tap and hold on it and then swipe on it. You can change the color, shape, size, and orientation of the item. You can also combine items to create new ones.</p>
- <h2>Conclusion</h2>
-<p>Mini Block Craft Mod Menu APK is a modified version of Mini Block Craft that gives you more features and options. You can get unlimited money, free craft, no ads, and more. You can also access other cheats and hacks from the menu, such as speed hack, fly hack, god mode, etc. You can also enjoy some extra features that are not available in the original version, such as night mode, weather mode, etc. You can download and install Mini Block Craft Mod Menu APK from a reliable source and enjoy the game.</p>
- <h4>Summary of the article</h4>
-<p>In this article, we have covered the following topics:</p>
-<ul>
-<li>What is Mini Block Craft and its features.</li>
-<li>What is Mini Block Craft Mod Menu APK and its benefits.</li>
-<li>How to download and install Mini Block Craft Mod Menu APK.</li>
-<li>How to use Mini Block Craft Mod Menu APK.</li>
-<li>Tips and tricks for Mini Block Craft Mod Menu APK.</li>
-</ul>
- <h4>FAQs</h4>
-<p>Here are some frequently asked questions about Mini Block Craft Mod Menu APK:</p>
-<ol>
-<li>Is Mini Block Craft Mod Menu APK safe to use?</li>
-<p>Mini Block Craft Mod Menu APK is safe to use as long as you download it from a reliable source and scan it for viruses before installing it. However, you should be careful when using the mod menu as some cheats and hacks may cause glitches or crashes in the game. You should also backup your data before using the mod menu in case anything goes wrong.</p>
-<li>Is Mini Block Craft Mod Menu APK compatible with all devices?</li>
-<p>Mini Block Craft Mod Menu APK is compatible with most Android devices that support the original version of Mini Block Craft. However, some devices may not be able to run the mod menu smoothly or at all due to different specifications or settings. You should check the compatibility of your device before downloading and installing the mod menu.</p>
-<li>Can I play online with Mini Block Craft Mod Menu APK?</li>
-<p>You can play online with Mini Block Craft Mod Menu APK as long as you do not use any cheats or hacks that may affect other players or servers. For example, you should not use speed hack, fly hack, god mode, etc. when playing online as these may give you an unfair advantage or disrupt the game balance. You should also respect other players and their worlds and not cause any trouble or damage.</p>
-<li>Can I update Mini Block Craft Mod Menu APK?</li>
-<p>You can update Mini Block Craft Mod Menu APK whenever there is a new version available from the source you downloaded it from. However, you should be aware that updating the mod menu may cause some issues or errors in the game or remove some features or options from the menu. You should always backup your data before updating the mod menu in case anything goes wrong.</p>
-<li>How can I contact the developers of Mini Block Craft Mod Menu APK?</li>
-<p>You can contact the developers of Mini Block Craft Mod Menu APK by visiting their website or social media pages if they have any. You can also leave a comment or feedback on the source you downloaded it from or on any forum or platform where they are active. However, you should not expect a quick or positive response from them as they are unknown modders who may not have official support or communication channels.</p>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/fatiXbelha/sd/Fights Break Sphere S2 Xiao Yans Journey to Save His Father [Sub Indo].md b/spaces/fatiXbelha/sd/Fights Break Sphere S2 Xiao Yans Journey to Save His Father [Sub Indo].md
deleted file mode 100644
index edc52b1dc9869da216e38da349c9db014adeb60b..0000000000000000000000000000000000000000
--- a/spaces/fatiXbelha/sd/Fights Break Sphere S2 Xiao Yans Journey to Save His Father [Sub Indo].md	
+++ /dev/null
@@ -1,118 +0,0 @@
-<br />
-<h1>Download Film Fights Break Sphere Season 2 Sub Indo: A Guide for Fans of Wuxia Fantasy</h1>
- <p>If you are a fan of wuxia fantasy, you might have heard of Fights Break Sphere, a Chinese drama series based on a novel of the same name by Tian Can Tu Dou. The first season aired in 2018 and received positive reviews from critics and viewers alike. The second season, which premiered in 2023, continued the story of the hot-blooded youth Xiao Yan, who strives to restore his family's glory and become a powerful martial artist.</p>
-<h2>download film fights break sphere season 2 sub indo</h2><br /><p><b><b>Download</b> ---> <a href="https://urllie.com/2uNGh9">https://urllie.com/2uNGh9</a></b></p><br /><br />
- <p>In this article, we will tell you everything you need to know about Fights Break Sphere Season 2, and how to download film fights break sphere season 2 sub indo. Whether you want to watch it online or offline, with subtitles or without, we have got you covered. Read on to find out more.</p>
- <h2>What is Fights Break Sphere Season 2?</h2>
- <h3>The plot of the second season</h3>
- <p>Fights Break Sphere Season 2 follows Xiao Yan as he returns to Jianan Academy after fulfilling his three-year promise with Nalan Yanran, his former fiancée. However, his family is attacked by the Yunlan Sect, and his father Xiao Zhan is taken captive. To save his father and avenge his family, Xiao Yan decides to improve his cultivation and challenge the Yunlan Sect. Along the way, he meets new friends and enemies, as well as old flames and rivals.</p>
- <h3>The cast and characters of the second season</h3>
- <p>The second season features some familiar faces from the first season, as well as some new additions. Here are some of the main cast and characters of Fights Break Sphere Season 2:</p>
- <table>
-<tr>
-<th>Name</th>
-<th>Role</th>
-<th>Character</th>
-</tr>
-<tr>
-<td>He Luo Luo</td>
-<td>Main Role</td>
-<td>Xiao Yan, the protagonist and a genius martial artist who lost his powers at a young age.</td>
-</tr>
-<tr>
-<td>Ding Xiao Ying</td>
-<td>Main Role</td>
-<td>Xiao Xun Er / Gu Xun Er, Xiao Yan's childhood sweetheart and a mysterious girl with a hidden identity.</td>
-</tr>
-<tr>
-<td>Gu Yu Han</td>
-<td>Support Role</td>
-<td>Zi Yan, a playful and powerful girl who can transform into a dragon.</td>
-</tr>
-<tr>
-<td>Wang Xiu Zhu</td>
-<td>Support Role</td>
-<td>Mei Du Sha, a cold and ruthless woman who is the leader of the Poison Sect.</td>
-</tr>
-<tr>
-<td>Qiu Xin Zhi</td>
-<td>Support Role</td>
-<td>Yao Chen, Xiao Yan's master and a legendary alchemist.</td>
-</tr>
-<tr>
-<td>Lu Yu Xiao</td>
-<td>Support Role</td>
-<td>Xiao Yi Xian, a gentle and kind-hearted girl who has a deadly poison in her body.</td>
-</tr>
-</table>
- <h2>Why should you watch Fights Break Sphere Season 2?</h2>
- <h3>The stunning visual effects and action scenes</h3>
- <p>One of the reasons why you should watch Fights Break Sphere Season 2 is because of its amazing visual effects and action scenes. The show uses advanced technology to create realistic and immersive scenes of martial arts, magic, and fantasy. You will be amazed by the spectacular display of fire, ice, lightning , and other elements as the characters unleash their skills and techniques. You will also be thrilled by the intense and exciting fights between Xiao Yan and his opponents, as they clash with their fists, swords, and weapons. The show does not skimp on the details and quality of the visual effects and action scenes, making it a feast for the eyes.</p>
- <h3>The captivating romance and friendship</h3>
- <p>Another reason why you should watch Fights Break Sphere Season 2 is because of its captivating romance and friendship. The show depicts the complex and dynamic relationships between Xiao Yan and the people around him, especially the women who love him. You will be touched by the sweet and romantic moments between Xiao Yan and Xiao Xun Er, who share a deep bond since childhood. You will also be intrigued by the ambiguous and tense relationship between Xiao Yan and Mei Du Sha, who have a history of hatred and attraction. You will also be moved by the loyal and supportive friendship between Xiao Yan and Zi Yan, who always stand by his side. The show explores the different facets of love and friendship, making it a heartwarming and emotional experience.</p>
- <h3>The faithful adaptation of the popular novel</h3>
- <p>The last reason why you should watch Fights Break Sphere Season 2 is because of its faithful adaptation of the popular novel. The show follows the original story of the novel by Tian Can Tu Dou, which has over 10 million readers online. The show respects the author's vision and creativity, and does not deviate from the main plot and characters. The show also incorporates some of the novel's iconic scenes and dialogues, making it a treat for the fans of the novel. The show also adds some original elements and twists, making it a fresh and interesting adaptation. The show is a perfect example of how to adapt a novel into a drama, making it a satisfying and enjoyable watch.</p>
- <h2>How to download Fights Break Sphere Season 2 sub indo?</h2>
- <h3>The legal and safe way to stream or download the show</h3>
- <p>If you want to watch Fights Break Sphere Season 2 sub indo, you might be wondering how to stream or download the show legally and safely. The good news is that there are some options available for you to do so. The best option is to use iQiyi, which is the official platform that produces and distributes Fights Break Sphere Season 2. iQiyi is a Chinese online video platform that offers a variety of content, including dramas, movies, variety shows, anime, and more. You can access iQiyi through its website or app, which are both available in multiple languages, including Indonesian. You can watch Fights Break Sphere Season 2 sub indo on iQiyi for free with ads, or you can subscribe to iQiyi VIP for a monthly fee to enjoy ad-free viewing, HD quality, exclusive content, and more benefits. You can also download Fights Break Sphere Season 2 sub indo on iQiyi app for offline viewing, as long as you have enough storage space on your device.</p>
- <h3>The best websites and apps to watch Fights Break Sphere Season 2 sub indo</h3>
- <p>If you are looking for other websites or apps to watch Fights Break Sphere Season 2 sub indo, you might want to check out these alternatives:</p>
-<p>download film fights break sphere season 2 sub indo full episode<br />
-download film fights break sphere season 2 sub indo wetv<br />
-download film fights break sphere season 2 sub indo gratis<br />
-download film fights break sphere season 2 sub indo mp4<br />
-download film fights break sphere season 2 sub indo hd<br />
-download film fights break sphere season 2 sub indo streaming<br />
-download film fights break sphere season 2 sub indo lk21<br />
-download film fights break sphere season 2 sub indo terbaru<br />
-download film fights break sphere season 2 sub indo batch<br />
-download film fights break sphere season 2 sub indo xxi<br />
-download film fights break sphere season 2 sub indo bioskopkeren<br />
-download film fights break sphere season 2 sub indo drakorindo<br />
-download film fights break sphere season 2 sub indo dunia21<br />
-download film fights break sphere season 2 sub indo juraganfilm<br />
-download film fights break sphere season 2 sub indo layarkaca21<br />
-download film fights break sphere season 2 sub indo nonton online<br />
-download film fights break sphere season 2 sub indo gudangmovies21<br />
-download film fights break sphere season 2 sub indo indomovie88<br />
-download film fights break sphere season 2 sub indo rebahin<br />
-download film fights break sphere season 2 sub indo sobatkeren<br />
-download film fights break sphere season 2 sub indo kawanfilm21<br />
-download film fights break sphere season 2 sub indo cinemaindo<br />
-download film fights break sphere season 2 sub indo filmapik<br />
-download film fights break sphere season 2 sub indo dramacute<br />
-download film fights break sphere season 2 sub indo dramaindo<br />
-download film fights break sphere season 2 sub indo dramaluv<br />
-download film fights break sphere season 2 sub indo dramazon<br />
-download film fights break sphere season 2 sub indo indoflix<br />
-download film fights break sphere season 2 sub indo indofilm<br />
-download film fights break sphere season 2 sub indo kebioskop21<br />
-download film fights break sphere season 2 sub indo lebahmovie<br />
-download film fights break sphere season 2 sub indo moviegan<br />
-download film fights break sphere season 2 sub indo movindo21<br />
-download film fights break sphere season 2 sub indo neonime<br />
-download film fights break sphere season 2 sub indo oploverz<br />
-download film fights break sphere season 2 sub indo pahe.in<br />
-download film fights break sphere season 2 sub indo pusatfilm21<br />
-download film fights break sphere season 2 sub indo savefilm21<br />
-download film fights break sphere season 2 sub indo samehadaku<br />
-download film fights break sphere season 2 sub indo semogafilm</p>
- - Dramacool: Dramacool is one of the most popular websites to watch Asian dramas online for free. It has a large collection of dramas from various countries, including China, Korea, Japan, Taiwan, Thailand, and more. You can find Fights Break Sphere Season 2 sub indo on Dramacool under its English title Battle Through The Heavens Season 2. You can stream or download Fights Break Sphere Season 2 sub indo on Dramacool with fast loading speed and good quality. However, you might encounter some pop-up ads or broken links on Dramacool, so be careful when using it. - WeTV: WeTV is another online video platform that offers Asian dramas, movies, variety shows, anime, and more. It is owned by Tencent, which is one of the largest internet companies in China. You can watch Fights Break Sphere Season 2 sub indo on WeTV under its Chinese title Dou Po Cang Qiong Zhi Da Zhu Zai. You can stream or download Fights Break Sphere Season 2 sub indo on WeTV for free with ads, or you can upgrade to WeTV VIP for a monthly fee to enjoy ad-free viewing, HD quality, exclusive content, and more benefits. You can also access WeTV through its website or app, which are both available in multiple languages , including Indonesian. However, you might need to use a VPN to access WeTV if it is not available in your region. - Viu: Viu is another online video platform that offers Asian dramas, movies, variety shows, anime, and more. It is owned by PCCW, which is a Hong Kong-based telecommunications company. You can watch Fights Break Sphere Season 2 sub indo on Viu under its English title Fights Break Sphere: Return of the Beasts. You can stream or download Fights Break Sphere Season 2 sub indo on Viu for free with ads, or you can subscribe to Viu Premium for a monthly fee to enjoy ad-free viewing, HD quality, exclusive content, and more benefits. You can also access Viu through its website or app, which are both available in multiple languages, including Indonesian. However, you might need to use a VPN to access Viu if it is not available in your region. <h3>The tips and tricks to enjoy Fights Break Sphere Season 2 sub indo</h3>
- <p>Now that you know how to download film fights break sphere season 2 sub indo, here are some tips and tricks to enjoy the show even more:</p>
- - Watch the first season before the second season: If you have not watched the first season of Fights Break Sphere, we recommend that you do so before watching the second season. The first season introduces the main characters and the background of the story, and sets up the conflicts and challenges that Xiao Yan faces. The second season continues from where the first season left off, and assumes that you are familiar with the previous events and developments. Watching the first season will help you understand the second season better, and appreciate the growth and changes of the characters. - Read the novel or the manga: If you want to know more about the story and the world of Fights Break Sphere, you can also read the novel or the manga that inspired the show. The novel is written by Tian Can Tu Dou, and has over 1600 chapters. The manga is drawn by Ren Xiang, and has over 300 chapters. Both the novel and the manga are available online in various languages, including Indonesian. Reading the novel or the manga will give you more details and insights into the plot and the characters, and also show you some differences and similarities between the original source and the adaptation. - Join the fan community: If you want to share your thoughts and feelings about Fights Break Sphere Season 2 with other fans, you can also join the fan community online. There are many platforms where you can find other fans of Fights Break Sphere, such as social media, forums, blogs, podcasts, etc. You can also find some fan-made content, such as fan art, fan fiction, fan videos, etc. Joining the fan community will make you feel more connected and engaged with Fights Break Sphere Season 2, and also help you discover new perspectives and opinions about the show. <h2>Conclusion</h2>
- <p>Fights Break Sphere Season 2 is a must-watch for fans of wuxia fantasy. It is a thrilling and captivating show that combines martial arts, magic, romance, friendship, and adventure. It is also a faithful and impressive adaptation of a popular novel by Tian Can Tu Dou. If you want to download film fights break sphere season 2 sub indo, you can use iQiyi as the best option, or try other alternatives such as Dramacool, WeTV, or Viu. You can also follow some tips and tricks to enjoy Fights Break Sphere Season 2 even more.</p>
- <p>We hope that this article has helped you learn more about Fights Break Sphere Season 2, and how to download film fights break sphere season 2 sub indo. If you have any questions or comments, feel free to leave them below. Thank you for reading.</p>
- <h2>FAQs</h2>
- <h3>Q: How many episodes are there in Fights Break Sphere Season 2?</h3>
-<p>A: There are 24 episodes in Fights Break Sphere Season 2.</p>
- <h3>Q: When did Fights Break Sphere Season 2 air?</h3>
-<p>A: Fights Break Sphere Season 2 aired from June 3 to July 22 in 2023.</p>
- <h3>Q: Who sings the opening and ending songs of Fights Break Sphere Season 2?</h3>
-<p>A: The opening song of Fights Break Sphere Season 2 is "Break Through" by He Luo Luo (who plays Xiao Yan), while the ending song is "Waiting For You" by Ding Xiao Ying (who plays Xiao Xun Er).</p>
- <h3>Q: What is wuxia fantasy?</h3>
-<p>A: Wuxia fantasy is a genre of fiction that combines elements of wuxia (martial arts) and fantasy (magic). It usually features heroes who practice martial arts and magic, and have adventures in a fantasy world. Wuxia fantasy is a popular genre in Chinese literature, film, and television.</p>
- <h3>Q: What are some other wuxia fantasy shows that you can watch?</h3>
-<p>A: Some other wuxia fantasy shows that you can watch are:</p>
- - The Untamed: The Untamed is a 2019 Chinese drama series based on a novel by Mo Xiang Tong Xiu. It tells the story of Wei Wuxian and Lan Wangji, two cultivators who solve mysteries and fight evil in a world of magic and martial arts. - Ever Night: Ever Night is a 2018 Chinese drama series based on a novel by Mao Ni. It tells the story of Ning Que, a young boy who survives a massacre and becomes a powerful warrior who protects the world from a dark prophecy. - Legend of Fei: Legend of Fei is a 2020 Chinese drama series based on a novel by Priest. It tells the story of Zhou Fei, a daughter of a legendary swordsman who joins forces with Xie Yun, a mysterious thief who has a hidden identity.</p> 401be4b1e0<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/fb700/chatglm-fitness-RLHF/src/face3d/models/arcface_torch/configs/base.py b/spaces/fb700/chatglm-fitness-RLHF/src/face3d/models/arcface_torch/configs/base.py
deleted file mode 100644
index 78e4b36a9142b649ec39a8c59331bb2557f2ad57..0000000000000000000000000000000000000000
--- a/spaces/fb700/chatglm-fitness-RLHF/src/face3d/models/arcface_torch/configs/base.py
+++ /dev/null
@@ -1,56 +0,0 @@
-from easydict import EasyDict as edict
-
-# make training faster
-# our RAM is 256G
-# mount -t tmpfs -o size=140G  tmpfs /train_tmp
-
-config = edict()
-config.loss = "arcface"
-config.network = "r50"
-config.resume = False
-config.output = "ms1mv3_arcface_r50"
-
-config.dataset = "ms1m-retinaface-t1"
-config.embedding_size = 512
-config.sample_rate = 1
-config.fp16 = False
-config.momentum = 0.9
-config.weight_decay = 5e-4
-config.batch_size = 128
-config.lr = 0.1  # batch size is 512
-
-if config.dataset == "emore":
-    config.rec = "/train_tmp/faces_emore"
-    config.num_classes = 85742
-    config.num_image = 5822653
-    config.num_epoch = 16
-    config.warmup_epoch = -1
-    config.decay_epoch = [8, 14, ]
-    config.val_targets = ["lfw", ]
-
-elif config.dataset == "ms1m-retinaface-t1":
-    config.rec = "/train_tmp/ms1m-retinaface-t1"
-    config.num_classes = 93431
-    config.num_image = 5179510
-    config.num_epoch = 25
-    config.warmup_epoch = -1
-    config.decay_epoch = [11, 17, 22]
-    config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
-
-elif config.dataset == "glint360k":
-    config.rec = "/train_tmp/glint360k"
-    config.num_classes = 360232
-    config.num_image = 17091657
-    config.num_epoch = 20
-    config.warmup_epoch = -1
-    config.decay_epoch = [8, 12, 15, 18]
-    config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
-
-elif config.dataset == "webface":
-    config.rec = "/train_tmp/faces_webface_112x112"
-    config.num_classes = 10572
-    config.num_image = "forget"
-    config.num_epoch = 34
-    config.warmup_epoch = -1
-    config.decay_epoch = [20, 28, 32]
-    config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
diff --git a/spaces/fclong/summary/fengshen/examples/deepVAE/pretrain_deep_vae.py b/spaces/fclong/summary/fengshen/examples/deepVAE/pretrain_deep_vae.py
deleted file mode 100644
index 37884261d487b6d43e1c682f15b7fde6e3beb709..0000000000000000000000000000000000000000
--- a/spaces/fclong/summary/fengshen/examples/deepVAE/pretrain_deep_vae.py
+++ /dev/null
@@ -1,141 +0,0 @@
-import torch
-import os
-import random
-import math
-import argparse
-from fengshen.data.fs_datasets.fs_datamodule import FSDataModule
-from fengshen.example.deepVAE.vae_pl_module import DeepVAEModule
-
-from pytorch_lightning import (
-    Trainer,
-    loggers,
-)
-
-from pytorch_lightning.callbacks import ModelCheckpoint, LearningRateMonitor
-from torch.nn.utils.rnn import pad_sequence
-
-
-class NER_RE_Collator:
-    def __init__(self, bos_token, eos_token, sep_token) -> None:
-        self.bos_token = bos_token
-        self.eos_token = eos_token
-        self.sep_token = sep_token
-
-    def __call__(self, samples, max_len=128):
-        # when len(samples) is larger than one, we need to save the sentence length info
-        inputs_tensors, entity_tensors = [], []
-        for sp in samples:
-            # NOTE: in TD-VAE, both encoder and decoder are gpt2, thus use decoder sent twice !
-            input_entities, input_ids = sp['decoder_entities'], sp['decoder_target']
-            input_entities = input_entities[:max_len] + [self.sep_token]
-            # shorten input_ids, based on the fact that sentence must be longer than the entities
-            input_ids = [self.bos_token] + input_ids[:max_len] + [self.eos_token]
-            entity_tensors.append(torch.tensor(input_entities, dtype=torch.long))
-            inputs_tensors.append(torch.tensor(input_ids, dtype=torch.long))
-        if not inputs_tensors or not entity_tensors:
-            return None  # if all the examples in the batch exceed max_length sentence
-        inputs_tensors = pad_sequence(inputs_tensors, batch_first=True, padding_value=0)
-        entity_tensors = pad_sequence(entity_tensors, batch_first=True, padding_value=0)
-        return inputs_tensors, entity_tensors
-
-
-class TDVAECollator:
-    def __init__(self, bos_token, eos_token) -> None:
-        self.bos_token = bos_token
-        self.eos_token = eos_token
-
-    def __call__(self, samples, max_len=120):
-        # when len(samples) is larger than one, we need to save the sentence length info
-        inputs = []
-        for sp in samples:
-            # NOTE: in TD-VAE, both encoder and decoder are gpt2, thus use decoder sent twice !
-            sent_lengths, input_ids = sp['decoder_sent_lengths'], sp['decoder_target']
-            potential_indices = [idx for idx, slen in enumerate(sent_lengths) if slen < max_len]
-            if len(potential_indices) == 0:
-                continue  # we ignore paragraphs with only one sentence split
-            selected_idx = random.choice(potential_indices)
-            start_pos, end_pos = sum(sent_lengths[:selected_idx]), sum(sent_lengths[:selected_idx])+sent_lengths[selected_idx]
-            selected_input_ids = [self.bos_token] + input_ids[start_pos:end_pos] + [self.eos_token]
-            inputs.append(torch.tensor(selected_input_ids, dtype=torch.long))
-        if not inputs:
-            return None  # if all the examples in the batch exceed max_length sentence
-        inputs = pad_sequence(inputs, batch_first=True, padding_value=0)
-        return inputs
-
-
-class ZH_Fin_Collator:
-    def __init__(self, bos_token, eos_token) -> None:
-        self.bos_token = bos_token
-        self.eos_token = eos_token
-
-    def __call__(self, samples, max_len=120):
-        inputs = []
-        for sp in samples:
-            # NOTE: in TD-VAE, both encoder and decoder are gpt2, thus use decoder sent twice !
-            input_ids = sp['input_ids']
-            if len(input_ids) == 0:
-                continue  # we ignore paragraphs with empty string
-            selected_input_ids = [self.bos_token] + input_ids + [self.eos_token]
-            inputs.append(torch.tensor(selected_input_ids, dtype=torch.long))
-        if not inputs:
-            return None
-        inputs = pad_sequence(inputs, batch_first=True, padding_value=0)
-        return inputs
-
-
-class VAEModelCheckpoint:
-    @ staticmethod
-    def add_argparse_args(parent_args):
-        parser = parent_args.add_argument_group('BaseModel')
-
-        parser.add_argument('--monitor', default='total_loss', type=str)
-        parser.add_argument('--mode', default='min', type=str)
-        parser.add_argument('--dirpath', default='./log/', type=str)
-        parser.add_argument('--filename', default='model-{epoch:2d}-{train_loss:.4f}', type=str)
-
-        parser.add_argument('--save_top_k', default=-1, type=int)
-        parser.add_argument('--every_n_train_steps', default=1000, type=float)
-        parser.add_argument('--save_weights_only', default=True, type=bool)
-
-        return parent_args
-
-    @staticmethod
-    def get_callback(args):
-        return ModelCheckpoint(monitor=args.monitor,
-                               save_top_k=args.save_top_k,
-                               mode=args.mode,
-                               every_n_train_steps=args.every_n_train_steps,
-                               save_weights_only=args.save_weights_only,
-                               dirpath=args.dirpath,
-                               filename=args.filename)
-
-
-if __name__ == '__main__':
-    args_parser = argparse.ArgumentParser()
-
-    args_parser = FSDataModule.add_data_specific_args(args_parser)
-    args_parser = Trainer.add_argparse_args(args_parser)
-    args_parser = DeepVAEModule.add_module_specific_args(args_parser)
-    args_parser = VAEModelCheckpoint.add_argparse_args(args_parser)
-
-    args = args_parser.parse_args()
-    # TODO: update this to be tokenizer specific
-    # collator = NER_RE_Collator(bos_token=21128, eos_token=21129, sep_token=102)
-    # collator = TDVAECollator(bos_token=21128, eos_token=21129)
-    collator = ZH_Fin_Collator(bos_token=21128, eos_token=21129)
-
-    data_module = FSDataModule(args=args, collate_fn=collator)
-
-    train_steps = math.ceil(len(data_module.train_dataset)*args.max_epochs /
-                            args.train_batchsize / args.num_nodes / args.gpus)
-    model = DeepVAEModule(args, train_steps)
-
-    logger = loggers.TensorBoardLogger(save_dir=os.path.join(
-        args.default_root_dir, 'logs/'), name='deepvae_lightning')
-
-    save_cpt_callback = VAEModelCheckpoint.get_callback(args)
-    lr_monitor = LearningRateMonitor(logging_interval='step')
-    trainer = Trainer.from_argparse_args(args,
-                                         callbacks=[save_cpt_callback, lr_monitor],
-                                         logger=logger)
-    trainer.fit(model, data_module)
diff --git a/spaces/feregVcuzo/sanity-test-midi/Herbert Lockyer All Series Pdf 140.md b/spaces/feregVcuzo/sanity-test-midi/Herbert Lockyer All Series Pdf 140.md
deleted file mode 100644
index fde7466d51ea4d4342692addef19c0dcdfd6381d..0000000000000000000000000000000000000000
--- a/spaces/feregVcuzo/sanity-test-midi/Herbert Lockyer All Series Pdf 140.md	
+++ /dev/null
@@ -1,74 +0,0 @@
-## Herbert Lockyer All Series Pdf 140
-
-
-
- 
-
- 
-
- 
-
- 
-
-**LINK ===> [https://apconhanstraf.blogspot.com/?c=2tyq88](https://apconhanstraf.blogspot.com/?c=2tyq88)**
-
-
-
- 
-
- 
-
- 
-
- 
-
- 
-
-# Herbert Lockyer: A Prolific Author of Biblical Studies
-
- 
-
-Herbert Lockyer (1886–1985) was a British Baptist minister and an internationally known preacher. He wrote approximately fifty books on various topics related to the Bible, such as prophecy, prayer, miracles, angels, and women. His most famous work is the *All Series*, a collection of 21 volumes that covers every major theme and person in the Scriptures.
-
- 
-
-One of the volumes in the *All Series* is *All the Parables of the Bible*, which contains 140 parables that Jesus and the Old Testament prophets used to illustrate spiritual truths. Lockyer provides a comprehensive analysis of each parable, explaining its historical and cultural background, its main message, and its practical application. He also compares and contrasts the different parables and shows how they relate to each other and to the overall plan of God.
-
- 
-
-Lockyer's books are rich in biblical insights and devotional warmth. They are designed to help readers understand the Bible better and apply it to their lives. Lockyer's books are available in various formats, including print, ebook, and Logos Bible Software. Logos Bible Software allows users to access Lockyer's books along with thousands of other resources on their computers, tablets, or phones. Users can also search, compare, cross-reference, and study Lockyer's books with ease and convenience.
-
- 
-
-Herbert Lockyer was a gifted teacher and writer who devoted his life to spreading the gospel and expounding the Word of God. His books are still relevant and useful today for anyone who wants to grow in their knowledge and love of God.
-
-  
-
-One of the reasons why Lockyer's books are so valuable is that they are based on his extensive research and scholarship. Lockyer studied at Glasgow Bible College and received doctoral degrees from Northwestern Evangelical Seminary and the International Academy in London. He also traveled widely and visited many biblical sites and historical places. He used his knowledge and experience to enrich his books with accurate and reliable information.
-
- 
-
-Another reason why Lockyer's books are so helpful is that they are written in a clear and engaging style. Lockyer had a gift for communicating complex and profound truths in a simple and understandable way. He used illustrations, anecdotes, quotations, and examples to make his books interesting and enjoyable to read. He also had a passion for applying the Bible to everyday life and showing its relevance and importance for modern Christians.
-
- 
-
-Lockyer's books have been translated into many languages and have influenced millions of people around the world. Many pastors, teachers, students, and laypeople have benefited from his books and have used them as references, guides, and devotional aids. Lockyer's books are timeless classics that will continue to bless and inspire generations to come.
-
-  
-
-Lockyer's books cover a wide range of topics and themes that are relevant and important for biblical studies. Some of his books focus on specific books or sections of the Bible, such as the Psalms, the Prophets, the Gospels, or the Epistles. Some of his books explore specific doctrines or teachings of the Bible, such as the Trinity, the Holy Spirit, or the Second Coming. Some of his books examine specific aspects or features of the Bible, such as its names, its numbers, its miracles, or its prayers.
-
- 
-
-Lockyer's books also cover a wide range of characters and personalities that are found in the Bible. He wrote biographies and character studies of many biblical figures, such as Abraham, Moses, David, Elijah, Esther, Peter, Paul, and Mary. He also wrote about groups or categories of people in the Bible, such as the apostles, the prophets, the kings, the women, or the children. He showed how these people lived, what they did, what they said, and what we can learn from them.
-
- 
-
-Lockyer's books are not only informative but also inspirational. He wrote with a deep love and reverence for God and His Word. He wrote with a sincere desire to edify and encourage his readers in their faith and walk with God. He wrote with a humble spirit and a grateful heart for God's grace and mercy. He wrote with a hopeful vision and a joyful anticipation for God's kingdom and glory.
-
- dfd1c89656
-
- 
-
- 
-
diff --git a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Download Cursor One Piece - Spice Up Your Mouse with Luffy Zoro Sanji and More.md b/spaces/feregVcuzo/sanity-test-midi/checkpoint/Download Cursor One Piece - Spice Up Your Mouse with Luffy Zoro Sanji and More.md
deleted file mode 100644
index d0e9ff3d3f017414a4f4796282e4d9af24cad5ae..0000000000000000000000000000000000000000
--- a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Download Cursor One Piece - Spice Up Your Mouse with Luffy Zoro Sanji and More.md	
+++ /dev/null
@@ -1,123 +0,0 @@
-
-<h1>How to Download Cursor One Piece</h1>
-<p>If you are a fan of the popular anime and manga series One Piece, you might want to spice up your computer with some cool and colorful cursors based on your favorite characters and themes. In this article, we will show you how to download cursor one piece from different websites, how to install and use them on your computer, and why you should try them out. Let's get started!</p>
-<h2>download cursor one piece</h2><br /><p><b><b>Download</b> &#10002; <a href="https://gohhs.com/2uPqsj">https://gohhs.com/2uPqsj</a></b></p><br /><br />
- <h2>What is Cursor One Piece?</h2>
-<h3>A brief introduction to the anime and manga series One Piece</h3>
-<p>One Piece is a long-running anime and manga series by Eiichiro Oda that follows the adventures of Monkey D. Luffy, a young pirate who dreams of finding the legendary treasure called One Piece and becoming the king of pirates. Along his journey, he meets and recruits various crew members, each with their own unique abilities and personalities, and faces many enemies and challenges. The series is known for its humor, action, fantasy, and epic storylines.</p>
-<h3>A description of the cursor collection based on One Piece characters and themes</h3>
-<p>Cursor one piece is a collection of custom cursors that are inspired by the characters and themes of One Piece. You can choose from different cursors that feature Luffy, Zoro, Nami, Sanji, Chopper, Robin, Franky, Brook, Ace, Shanks, Law, Hancock, Mihawk, Katakuri, Buggy, and many more. You can also find cursors that represent the Straw Hat Pirates' flag, Luffy's hat, swords, guns, fruits, animals, and other items related to One Piece. The cursors are colorful, animated, and fun to use.</p>
- <h2>Why Download Cursor One Piece?</h2>
-<h3>The benefits of customizing your mouse pointer with cursor one piece</h3>
-<p>Downloading cursor one piece can make your computer more personalized and enjoyable. You can express your love for One Piece and show off your favorite characters or themes. You can also change your cursor according to your mood or preference. For example, you can use a cute Chopper cursor when you are feeling happy or a fierce Zoro cursor when you are feeling serious. You can also match your cursor with your wallpaper or theme for a more harmonious look.</p>
-<h3>The features and variety of cursor one piece</h3>
-<p>Cursor one piece has many features and variety that make it stand out from other cursor collections. For example:</p>
-<ul>
-<li>Cursor one piece has high-quality graphics and animations that make the cursors look smooth and realistic.</li>
-<li>Cursor one piece has different types of cursors for different functions. For example, you can use a normal select cursor for clicking, a help select cursor for hovering over links or buttons, a text select cursor for highlighting text, a handwriting cursor for writing or drawing, a precision select cursor for selecting small areas or objects, a move cursor for dragging or moving items, a link select cursor for opening links or files, a location select cursor for changing locations or directions, a person select cursor for selecting people or contacts, and more.</li>
-<li>Cursor one piece has a wide range of cursors that cover almost every character and theme from One Piece. You can find cursors that represent the main characters, the supporting characters, the villains, the allies, the groups, the factions, the locations, the events, the objects, the symbols, and more from One Piece. You can also find cursors that are based on the different arcs or sagas of One Piece, such as East Blue, Alabasta, Skypiea, Water 7, Thriller Bark, Sabaody Archipelago, Impel Down, Marineford, Fishman Island, Punk Hazard, Dressrosa, Zou, Whole Cake Island, Wano Country, and more.</li>
-</ul>
- <h2>How to Download Cursor One Piece?</h2>
-<h3>The steps to download cursor one piece from different websites</h3>
-<p>There are many websites that offer cursor one piece for free download. Here are some of the most popular ones:</p>
-<p>download one piece cursor collection custom cursor<br />
-download one piece water seven cursors realworld graphics<br />
-download one piece luffy punter cursors<br />
-download one piece monkey d luffy early cursors<br />
-download onepiece by rizarproject cursors<br />
-download minecraft creeper one piece cursors<br />
-download pink to purple animated one piece cursors<br />
-download aph italy one piece cursors<br />
-download simple 3 piece arrow cursors<br />
-download one piece film red cursor<br />
-download one piece sanji help cursor<br />
-download one piece zoro working cursor<br />
-download one piece luffy busy cursor<br />
-download one piece ace precision cursor<br />
-download one piece luffy text cursor<br />
-download one piece sanji handwriting cursor<br />
-download one piece zoro unavailable cursor<br />
-download one piece luffy vertical cursor<br />
-download one piece luffy horizontal cursor<br />
-download one piece luffy diagonal 1 cursor<br />
-download one piece luffy diagonal 2 cursor<br />
-download one piece sanji move cursor<br />
-download one piece luffy transform alternate cursor<br />
-download one piece luffy link cursor<br />
-download one piece luffy location cursor<br />
-download one piece luffy person cursor<br />
-download one piece buchi cursor<br />
-download one piece nico olvia cursor<br />
-download one piece sham cursor<br />
-download one piece edward newgate and murakumogiri cursor<br />
-download one piece perona and umbrella cursor<br />
-download one piece bepo cursor<br />
-download one piece buggy the star clown cursor<br />
-download one piece uta cursor<br />
-download one piece vinsmoke niji cursor<br />
-download one piece dracule mihawk and yoru cursor<br />
-download one piece cavendish and durandal cursor<br />
-download one piece charlotte katakuri and mogura cursor<br />
-download one piece eustass kid and metal arm cursor<br />
-download one piece knight of the sea jinbe cursor<br />
-download custom-cursor.com en collection one-piece url <br />
-download rw-designer.com gallery search=one+piece+cursors url <br />
-download rw-designer.com cursor-set luffy-water-seven-punter url <br />
-how to use custom-cursor.com for chrome <br />
-how to use custom-cursor.com for windows <br />
-how to add custom-cursor.com to your web pages <br />
-how to make your own cursors with custom-cursor.com <br />
-how to customize your mouse pointer with custom-cursor.com <br />
-how to use rw-designer.com freeware cursor maker <br />
-how to suggest your favorite cursors on rw-designer.com</p>
-<table>
-<tr>
-<th>Website</th>
-<th>Link</th>
-<th>Description</th>
-</tr>
-<tr>
-<td>Cursor.cc</td>
-<td><a href=""></a></td>
-<td>A website that allows you to create and download custom cursors. You can browse through thousands of cursor one piece created by other users or make your own with the online editor.</td>
-</tr>
-<tr>
-<td>Cursors-4u.com</td>
-<td><a href=""></a></td>
-<td>A website that provides a large collection of cursor one piece and other anime cursors. You can download them as .cur or .ani files or use them directly on your browser with a code.</td>
-</tr>
-<tr>
-<td>Rw-designer.com</td>
-<td><a href=""></a></td>
-<td>A website that offers a variety of cursor one piece and other tools for creating and editing cursors. You can download them as .cur or .ani files or use them with the RealWorld Cursor Editor software.</td>
-</tr>
-<tr>
-<td>Custom-cursor.com</td>
-<td><a href=""></a></td>
-<td>A website that lets you download and install cursor one piece and other custom cursors as extensions for Chrome, Firefox, Edge, or Opera browsers. You can also use them on your desktop with the Custom Cursor app.</td>
-</tr>
-</table>
- <h3>The tips and tricks to install and use cursor one piece on your computer</h3>
-<p>Depending on the website and the file format you choose, there are different ways to install and use cursor one piece on your computer. Here are some general tips and tricks:</p>
-<ul>
-<li>If you download cursor one piece as .cur or .ani files, you need to save them in a folder on your computer. Then, you need to go to your mouse settings and change your pointer scheme to the folder where you saved the cursors. You can also assign different cursors for different functions by clicking on each pointer type and browsing for the cursor file you want.</li>
-<li>If you use cursor one piece directly on your browser with a code, you need to copy and paste the code into your HTML file or website. Then, you need to refresh your browser to see the changes. You can also customize the code by changing the URL of the cursor file or the size of the cursor.</li>
-<li>If you download and install cursor one piece as extensions for your browser, you need to enable the extension and select the cursor you want from the menu. You can also switch between different cursors by clicking on the extension icon or using keyboard shortcuts.</li>
-<li>If you download and install cursor one piece as an app for your desktop, you need to run the app and choose the cursor you want from the library. You can also create your own cursors with the app or upload your own images or sprites.</li>
-</ul>
- <h2>Conclusion</h2>
-<h3>A summary of the main points and a call to action</h3>
-<p>In conclusion, cursor one piece is a great way to customize your mouse pointer with your favorite characters and themes from One Piece. You can download cursor one piece from different websites, install and use them on your computer or browser, and enjoy their features and variety. If you are a fan of One Piece or anime in general, you should definitely try out cursor one piece and have some fun with your computer. Download cursor one piece today and join the adventure!</p>
- <h2>FAQs</h2>
-<h3>Q1: Is cursor one piece free to download and use?</h3>
-<p>A1: Yes, cursor one piece is free to download and use from most websites. However, some websites may require registration or subscription to access some features or content. You should always check the terms and conditions of each website before downloading or using their cursors.</p>
- <h3>Q2: How can I change my cursor back to the default one?</h3>
-<p>A2: You can change your cursor back to the default one by following the same steps you used to change it to cursor one piece, but selecting the default pointer scheme or cursor file instead. You can also disable or uninstall the extension or app that you used to install cursor one piece.</p>
- <h3>Q3: What are some other anime cursor collections that I can try?</h3>
-<p>A3: There are many other anime cursor collections that you can try, such as Naruto, Bleach, Dragon Ball, Fairy Tail, Attack on Titan, My Hero Academia, Demon Slayer, One Punch Man, and more. You can find them on the same websites that offer cursor one piece or search for them online.</p>
- <h3>Q4: How can I make my own cursors with One Piece sprites or images?</h3>
-<p>A4: You can make your own cursors with One Piece sprites or images by using online tools or software that allow you to create and edit cursors. For example, you can use Cursor.cc, Rw-designer.com, or Custom Cursor app to make your own cursors with One Piece sprites or images. You can also use Photoshop, GIMP, Paint.net, or other image editing software to make your own sprites or images and then convert them to cursors.</p>
- <h3>Q5: Where can I find more information about One Piece?</h3>
-<p>A5: You can find more information about One Piece on the official website, the official Twitter account, the official YouTube channel, the Wikipedia page, the One Piece Wiki, the One Piece Reddit community, and other fan sites and forums.</p> 401be4b1e0<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/fffiloni/ControlVideo/models/controlnet_unet_blocks.py b/spaces/fffiloni/ControlVideo/models/controlnet_unet_blocks.py
deleted file mode 100644
index 75a3bfb5d7994a682fe8896180dd614910a69a07..0000000000000000000000000000000000000000
--- a/spaces/fffiloni/ControlVideo/models/controlnet_unet_blocks.py
+++ /dev/null
@@ -1,589 +0,0 @@
-# Adapted from https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unet_2d_blocks.py
-
-import torch
-from torch import nn
-
-from .controlnet_attention import Transformer3DModel
-from .resnet import Downsample3D, ResnetBlock3D, Upsample3D
-
-
-def get_down_block(
-    down_block_type,
-    num_layers,
-    in_channels,
-    out_channels,
-    temb_channels,
-    add_downsample,
-    resnet_eps,
-    resnet_act_fn,
-    attn_num_head_channels,
-    resnet_groups=None,
-    cross_attention_dim=None,
-    downsample_padding=None,
-    dual_cross_attention=False,
-    use_linear_projection=False,
-    only_cross_attention=False,
-    upcast_attention=False,
-    resnet_time_scale_shift="default",
-):
-    down_block_type = down_block_type[7:] if down_block_type.startswith("UNetRes") else down_block_type
-    if down_block_type == "DownBlock3D":
-        return DownBlock3D(
-            num_layers=num_layers,
-            in_channels=in_channels,
-            out_channels=out_channels,
-            temb_channels=temb_channels,
-            add_downsample=add_downsample,
-            resnet_eps=resnet_eps,
-            resnet_act_fn=resnet_act_fn,
-            resnet_groups=resnet_groups,
-            downsample_padding=downsample_padding,
-            resnet_time_scale_shift=resnet_time_scale_shift,
-        )
-    elif down_block_type == "CrossAttnDownBlock3D":
-        if cross_attention_dim is None:
-            raise ValueError("cross_attention_dim must be specified for CrossAttnDownBlock3D")
-        return CrossAttnDownBlock3D(
-            num_layers=num_layers,
-            in_channels=in_channels,
-            out_channels=out_channels,
-            temb_channels=temb_channels,
-            add_downsample=add_downsample,
-            resnet_eps=resnet_eps,
-            resnet_act_fn=resnet_act_fn,
-            resnet_groups=resnet_groups,
-            downsample_padding=downsample_padding,
-            cross_attention_dim=cross_attention_dim,
-            attn_num_head_channels=attn_num_head_channels,
-            dual_cross_attention=dual_cross_attention,
-            use_linear_projection=use_linear_projection,
-            only_cross_attention=only_cross_attention,
-            upcast_attention=upcast_attention,
-            resnet_time_scale_shift=resnet_time_scale_shift,
-        )
-    raise ValueError(f"{down_block_type} does not exist.")
-
-
-def get_up_block(
-    up_block_type,
-    num_layers,
-    in_channels,
-    out_channels,
-    prev_output_channel,
-    temb_channels,
-    add_upsample,
-    resnet_eps,
-    resnet_act_fn,
-    attn_num_head_channels,
-    resnet_groups=None,
-    cross_attention_dim=None,
-    dual_cross_attention=False,
-    use_linear_projection=False,
-    only_cross_attention=False,
-    upcast_attention=False,
-    resnet_time_scale_shift="default",
-):
-    up_block_type = up_block_type[7:] if up_block_type.startswith("UNetRes") else up_block_type
-    if up_block_type == "UpBlock3D":
-        return UpBlock3D(
-            num_layers=num_layers,
-            in_channels=in_channels,
-            out_channels=out_channels,
-            prev_output_channel=prev_output_channel,
-            temb_channels=temb_channels,
-            add_upsample=add_upsample,
-            resnet_eps=resnet_eps,
-            resnet_act_fn=resnet_act_fn,
-            resnet_groups=resnet_groups,
-            resnet_time_scale_shift=resnet_time_scale_shift,
-        )
-    elif up_block_type == "CrossAttnUpBlock3D":
-        if cross_attention_dim is None:
-            raise ValueError("cross_attention_dim must be specified for CrossAttnUpBlock3D")
-        return CrossAttnUpBlock3D(
-            num_layers=num_layers,
-            in_channels=in_channels,
-            out_channels=out_channels,
-            prev_output_channel=prev_output_channel,
-            temb_channels=temb_channels,
-            add_upsample=add_upsample,
-            resnet_eps=resnet_eps,
-            resnet_act_fn=resnet_act_fn,
-            resnet_groups=resnet_groups,
-            cross_attention_dim=cross_attention_dim,
-            attn_num_head_channels=attn_num_head_channels,
-            dual_cross_attention=dual_cross_attention,
-            use_linear_projection=use_linear_projection,
-            only_cross_attention=only_cross_attention,
-            upcast_attention=upcast_attention,
-            resnet_time_scale_shift=resnet_time_scale_shift,
-        )
-    raise ValueError(f"{up_block_type} does not exist.")
-
-
-class UNetMidBlock3DCrossAttn(nn.Module):
-    def __init__(
-        self,
-        in_channels: int,
-        temb_channels: int,
-        dropout: float = 0.0,
-        num_layers: int = 1,
-        resnet_eps: float = 1e-6,
-        resnet_time_scale_shift: str = "default",
-        resnet_act_fn: str = "swish",
-        resnet_groups: int = 32,
-        resnet_pre_norm: bool = True,
-        attn_num_head_channels=1,
-        output_scale_factor=1.0,
-        cross_attention_dim=1280,
-        dual_cross_attention=False,
-        use_linear_projection=False,
-        upcast_attention=False,
-    ):
-        super().__init__()
-
-        self.has_cross_attention = True
-        self.attn_num_head_channels = attn_num_head_channels
-        resnet_groups = resnet_groups if resnet_groups is not None else min(in_channels // 4, 32)
-
-        # there is always at least one resnet
-        resnets = [
-            ResnetBlock3D(
-                in_channels=in_channels,
-                out_channels=in_channels,
-                temb_channels=temb_channels,
-                eps=resnet_eps,
-                groups=resnet_groups,
-                dropout=dropout,
-                time_embedding_norm=resnet_time_scale_shift,
-                non_linearity=resnet_act_fn,
-                output_scale_factor=output_scale_factor,
-                pre_norm=resnet_pre_norm,
-            )
-        ]
-        attentions = []
-
-        for _ in range(num_layers):
-            if dual_cross_attention:
-                raise NotImplementedError
-            attentions.append(
-                Transformer3DModel(
-                    attn_num_head_channels,
-                    in_channels // attn_num_head_channels,
-                    in_channels=in_channels,
-                    num_layers=1,
-                    cross_attention_dim=cross_attention_dim,
-                    norm_num_groups=resnet_groups,
-                    use_linear_projection=use_linear_projection,
-                    upcast_attention=upcast_attention,
-                )
-            )
-            resnets.append(
-                ResnetBlock3D(
-                    in_channels=in_channels,
-                    out_channels=in_channels,
-                    temb_channels=temb_channels,
-                    eps=resnet_eps,
-                    groups=resnet_groups,
-                    dropout=dropout,
-                    time_embedding_norm=resnet_time_scale_shift,
-                    non_linearity=resnet_act_fn,
-                    output_scale_factor=output_scale_factor,
-                    pre_norm=resnet_pre_norm,
-                )
-            )
-
-        self.attentions = nn.ModuleList(attentions)
-        self.resnets = nn.ModuleList(resnets)
-
-    def forward(self, hidden_states, temb=None, encoder_hidden_states=None, attention_mask=None, cross_attention_kwargs=None):
-        hidden_states = self.resnets[0](hidden_states, temb)
-        for attn, resnet in zip(self.attentions, self.resnets[1:]):
-            hidden_states = attn(hidden_states, encoder_hidden_states=encoder_hidden_states).sample
-            hidden_states = resnet(hidden_states, temb)
-
-        return hidden_states
-
-
-class CrossAttnDownBlock3D(nn.Module):
-    def __init__(
-        self,
-        in_channels: int,
-        out_channels: int,
-        temb_channels: int,
-        dropout: float = 0.0,
-        num_layers: int = 1,
-        resnet_eps: float = 1e-6,
-        resnet_time_scale_shift: str = "default",
-        resnet_act_fn: str = "swish",
-        resnet_groups: int = 32,
-        resnet_pre_norm: bool = True,
-        attn_num_head_channels=1,
-        cross_attention_dim=1280,
-        output_scale_factor=1.0,
-        downsample_padding=1,
-        add_downsample=True,
-        dual_cross_attention=False,
-        use_linear_projection=False,
-        only_cross_attention=False,
-        upcast_attention=False,
-    ):
-        super().__init__()
-        resnets = []
-        attentions = []
-
-        self.has_cross_attention = True
-        self.attn_num_head_channels = attn_num_head_channels
-
-        for i in range(num_layers):
-            in_channels = in_channels if i == 0 else out_channels
-            resnets.append(
-                ResnetBlock3D(
-                    in_channels=in_channels,
-                    out_channels=out_channels,
-                    temb_channels=temb_channels,
-                    eps=resnet_eps,
-                    groups=resnet_groups,
-                    dropout=dropout,
-                    time_embedding_norm=resnet_time_scale_shift,
-                    non_linearity=resnet_act_fn,
-                    output_scale_factor=output_scale_factor,
-                    pre_norm=resnet_pre_norm,
-                )
-            )
-            if dual_cross_attention:
-                raise NotImplementedError
-            attentions.append(
-                Transformer3DModel(
-                    attn_num_head_channels,
-                    out_channels // attn_num_head_channels,
-                    in_channels=out_channels,
-                    num_layers=1,
-                    cross_attention_dim=cross_attention_dim,
-                    norm_num_groups=resnet_groups,
-                    use_linear_projection=use_linear_projection,
-                    only_cross_attention=only_cross_attention,
-                    upcast_attention=upcast_attention,
-                )
-            )
-        self.attentions = nn.ModuleList(attentions)
-        self.resnets = nn.ModuleList(resnets)
-
-        if add_downsample:
-            self.downsamplers = nn.ModuleList(
-                [
-                    Downsample3D(
-                        out_channels, use_conv=True, out_channels=out_channels, padding=downsample_padding, name="op"
-                    )
-                ]
-            )
-        else:
-            self.downsamplers = None
-
-        self.gradient_checkpointing = False
-
-    def forward(self, hidden_states, temb=None, encoder_hidden_states=None, attention_mask=None,cross_attention_kwargs=None):
-        output_states = ()
-
-        for resnet, attn in zip(self.resnets, self.attentions):
-            if self.training and self.gradient_checkpointing:
-
-                def create_custom_forward(module, return_dict=None):
-                    def custom_forward(*inputs):
-                        if return_dict is not None:
-                            return module(*inputs, return_dict=return_dict)
-                        else:
-                            return module(*inputs)
-
-                    return custom_forward
-
-                hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
-                hidden_states = torch.utils.checkpoint.checkpoint(
-                    create_custom_forward(attn, return_dict=False),
-                    hidden_states,
-                    encoder_hidden_states,
-                )[0]
-            else:
-                hidden_states = resnet(hidden_states, temb)
-                hidden_states = attn(hidden_states, encoder_hidden_states=encoder_hidden_states).sample
-
-            output_states += (hidden_states,)
-
-        if self.downsamplers is not None:
-            for downsampler in self.downsamplers:
-                hidden_states = downsampler(hidden_states)
-
-            output_states += (hidden_states,)
-
-        return hidden_states, output_states
-
-
-class DownBlock3D(nn.Module):
-    def __init__(
-        self,
-        in_channels: int,
-        out_channels: int,
-        temb_channels: int,
-        dropout: float = 0.0,
-        num_layers: int = 1,
-        resnet_eps: float = 1e-6,
-        resnet_time_scale_shift: str = "default",
-        resnet_act_fn: str = "swish",
-        resnet_groups: int = 32,
-        resnet_pre_norm: bool = True,
-        output_scale_factor=1.0,
-        add_downsample=True,
-        downsample_padding=1,
-    ):
-        super().__init__()
-        resnets = []
-
-        for i in range(num_layers):
-            in_channels = in_channels if i == 0 else out_channels
-            resnets.append(
-                ResnetBlock3D(
-                    in_channels=in_channels,
-                    out_channels=out_channels,
-                    temb_channels=temb_channels,
-                    eps=resnet_eps,
-                    groups=resnet_groups,
-                    dropout=dropout,
-                    time_embedding_norm=resnet_time_scale_shift,
-                    non_linearity=resnet_act_fn,
-                    output_scale_factor=output_scale_factor,
-                    pre_norm=resnet_pre_norm,
-                )
-            )
-
-        self.resnets = nn.ModuleList(resnets)
-
-        if add_downsample:
-            self.downsamplers = nn.ModuleList(
-                [
-                    Downsample3D(
-                        out_channels, use_conv=True, out_channels=out_channels, padding=downsample_padding, name="op"
-                    )
-                ]
-            )
-        else:
-            self.downsamplers = None
-
-        self.gradient_checkpointing = False
-
-    def forward(self, hidden_states, temb=None):
-        output_states = ()
-
-        for resnet in self.resnets:
-            if self.training and self.gradient_checkpointing:
-
-                def create_custom_forward(module):
-                    def custom_forward(*inputs):
-                        return module(*inputs)
-
-                    return custom_forward
-
-                hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
-            else:
-                hidden_states = resnet(hidden_states, temb)
-
-            output_states += (hidden_states,)
-
-        if self.downsamplers is not None:
-            for downsampler in self.downsamplers:
-                hidden_states = downsampler(hidden_states)
-
-            output_states += (hidden_states,)
-
-        return hidden_states, output_states
-
-
-class CrossAttnUpBlock3D(nn.Module):
-    def __init__(
-        self,
-        in_channels: int,
-        out_channels: int,
-        prev_output_channel: int,
-        temb_channels: int,
-        dropout: float = 0.0,
-        num_layers: int = 1,
-        resnet_eps: float = 1e-6,
-        resnet_time_scale_shift: str = "default",
-        resnet_act_fn: str = "swish",
-        resnet_groups: int = 32,
-        resnet_pre_norm: bool = True,
-        attn_num_head_channels=1,
-        cross_attention_dim=1280,
-        output_scale_factor=1.0,
-        add_upsample=True,
-        dual_cross_attention=False,
-        use_linear_projection=False,
-        only_cross_attention=False,
-        upcast_attention=False,
-    ):
-        super().__init__()
-        resnets = []
-        attentions = []
-
-        self.has_cross_attention = True
-        self.attn_num_head_channels = attn_num_head_channels
-
-        for i in range(num_layers):
-            res_skip_channels = in_channels if (i == num_layers - 1) else out_channels
-            resnet_in_channels = prev_output_channel if i == 0 else out_channels
-
-            resnets.append(
-                ResnetBlock3D(
-                    in_channels=resnet_in_channels + res_skip_channels,
-                    out_channels=out_channels,
-                    temb_channels=temb_channels,
-                    eps=resnet_eps,
-                    groups=resnet_groups,
-                    dropout=dropout,
-                    time_embedding_norm=resnet_time_scale_shift,
-                    non_linearity=resnet_act_fn,
-                    output_scale_factor=output_scale_factor,
-                    pre_norm=resnet_pre_norm,
-                )
-            )
-            if dual_cross_attention:
-                raise NotImplementedError
-            attentions.append(
-                Transformer3DModel(
-                    attn_num_head_channels,
-                    out_channels // attn_num_head_channels,
-                    in_channels=out_channels,
-                    num_layers=1,
-                    cross_attention_dim=cross_attention_dim,
-                    norm_num_groups=resnet_groups,
-                    use_linear_projection=use_linear_projection,
-                    only_cross_attention=only_cross_attention,
-                    upcast_attention=upcast_attention,
-                )
-            )
-
-        self.attentions = nn.ModuleList(attentions)
-        self.resnets = nn.ModuleList(resnets)
-
-        if add_upsample:
-            self.upsamplers = nn.ModuleList([Upsample3D(out_channels, use_conv=True, out_channels=out_channels)])
-        else:
-            self.upsamplers = None
-
-        self.gradient_checkpointing = False
-
-    def forward(
-        self,
-        hidden_states,
-        res_hidden_states_tuple,
-        temb=None,
-        encoder_hidden_states=None,
-        upsample_size=None,
-        attention_mask=None,
-        cross_attention_kwargs=None
-    ):
-        for resnet, attn in zip(self.resnets, self.attentions):
-            # pop res hidden states
-            res_hidden_states = res_hidden_states_tuple[-1]
-            res_hidden_states_tuple = res_hidden_states_tuple[:-1]
-            hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
-
-            if self.training and self.gradient_checkpointing:
-
-                def create_custom_forward(module, return_dict=None):
-                    def custom_forward(*inputs):
-                        if return_dict is not None:
-                            return module(*inputs, return_dict=return_dict)
-                        else:
-                            return module(*inputs)
-
-                    return custom_forward
-
-                hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
-                hidden_states = torch.utils.checkpoint.checkpoint(
-                    create_custom_forward(attn, return_dict=False),
-                    hidden_states,
-                    encoder_hidden_states,
-                )[0]
-            else:
-                hidden_states = resnet(hidden_states, temb)
-                hidden_states = attn(hidden_states, encoder_hidden_states=encoder_hidden_states).sample
-
-        if self.upsamplers is not None:
-            for upsampler in self.upsamplers:
-                hidden_states = upsampler(hidden_states, upsample_size)
-
-        return hidden_states
-
-
-class UpBlock3D(nn.Module):
-    def __init__(
-        self,
-        in_channels: int,
-        prev_output_channel: int,
-        out_channels: int,
-        temb_channels: int,
-        dropout: float = 0.0,
-        num_layers: int = 1,
-        resnet_eps: float = 1e-6,
-        resnet_time_scale_shift: str = "default",
-        resnet_act_fn: str = "swish",
-        resnet_groups: int = 32,
-        resnet_pre_norm: bool = True,
-        output_scale_factor=1.0,
-        add_upsample=True,
-    ):
-        super().__init__()
-        resnets = []
-
-        for i in range(num_layers):
-            res_skip_channels = in_channels if (i == num_layers - 1) else out_channels
-            resnet_in_channels = prev_output_channel if i == 0 else out_channels
-
-            resnets.append(
-                ResnetBlock3D(
-                    in_channels=resnet_in_channels + res_skip_channels,
-                    out_channels=out_channels,
-                    temb_channels=temb_channels,
-                    eps=resnet_eps,
-                    groups=resnet_groups,
-                    dropout=dropout,
-                    time_embedding_norm=resnet_time_scale_shift,
-                    non_linearity=resnet_act_fn,
-                    output_scale_factor=output_scale_factor,
-                    pre_norm=resnet_pre_norm,
-                )
-            )
-
-        self.resnets = nn.ModuleList(resnets)
-
-        if add_upsample:
-            self.upsamplers = nn.ModuleList([Upsample3D(out_channels, use_conv=True, out_channels=out_channels)])
-        else:
-            self.upsamplers = None
-
-        self.gradient_checkpointing = False
-
-    def forward(self, hidden_states, res_hidden_states_tuple, temb=None, upsample_size=None):
-        for resnet in self.resnets:
-            # pop res hidden states
-            res_hidden_states = res_hidden_states_tuple[-1]
-            res_hidden_states_tuple = res_hidden_states_tuple[:-1]
-            hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
-
-            if self.training and self.gradient_checkpointing:
-
-                def create_custom_forward(module):
-                    def custom_forward(*inputs):
-                        return module(*inputs)
-
-                    return custom_forward
-
-                hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
-            else:
-                hidden_states = resnet(hidden_states, temb)
-
-        if self.upsamplers is not None:
-            for upsampler in self.upsamplers:
-                hidden_states = upsampler(hidden_states, upsample_size)
-
-        return hidden_states
diff --git a/spaces/firzaelbuho/rvc-models/infer_pack/models.py b/spaces/firzaelbuho/rvc-models/infer_pack/models.py
deleted file mode 100644
index 96165f73644e6fb92d0ffedb4a3c9e1a457cb989..0000000000000000000000000000000000000000
--- a/spaces/firzaelbuho/rvc-models/infer_pack/models.py
+++ /dev/null
@@ -1,982 +0,0 @@
-import math, pdb, os
-from time import time as ttime
-import torch
-from torch import nn
-from torch.nn import functional as F
-from infer_pack import modules
-from infer_pack import attentions
-from infer_pack import commons
-from infer_pack.commons import init_weights, get_padding
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from infer_pack.commons import init_weights
-import numpy as np
-from infer_pack import commons
-
-
-class TextEncoder256(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(256, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        stats = self.proj(x) * x_mask
-
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        return m, logs, x_mask
-
-
-class TextEncoder256Sim(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(256, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        x = self.proj(x) * x_mask
-        return x, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        n_flows=4,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.flows = nn.ModuleList()
-        for i in range(n_flows):
-            self.flows.append(
-                modules.ResidualCouplingLayer(
-                    channels,
-                    hidden_channels,
-                    kernel_size,
-                    dilation_rate,
-                    n_layers,
-                    gin_channels=gin_channels,
-                    mean_only=True,
-                )
-            )
-            self.flows.append(modules.Flip())
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        if not reverse:
-            for flow in self.flows:
-                x, _ = flow(x, x_mask, g=g, reverse=reverse)
-        else:
-            for flow in reversed(self.flows):
-                x = flow(x, x_mask, g=g, reverse=reverse)
-        return x
-
-    def remove_weight_norm(self):
-        for i in range(self.n_flows):
-            self.flows[i * 2].remove_weight_norm()
-
-
-class PosteriorEncoder(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.gin_channels = gin_channels
-
-        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-        self.enc = modules.WN(
-            hidden_channels,
-            kernel_size,
-            dilation_rate,
-            n_layers,
-            gin_channels=gin_channels,
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, x, x_lengths, g=None):
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.pre(x) * x_mask
-        x = self.enc(x, x_mask, g=g)
-        stats = self.proj(x) * x_mask
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
-        return z, m, logs, x_mask
-
-    def remove_weight_norm(self):
-        self.enc.remove_weight_norm()
-
-
-class Generator(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels=0,
-    ):
-        super(Generator, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-    def forward(self, x, g=None):
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-class SineGen(torch.nn.Module):
-    """Definition of sine generator
-    SineGen(samp_rate, harmonic_num = 0,
-            sine_amp = 0.1, noise_std = 0.003,
-            voiced_threshold = 0,
-            flag_for_pulse=False)
-    samp_rate: sampling rate in Hz
-    harmonic_num: number of harmonic overtones (default 0)
-    sine_amp: amplitude of sine-wavefrom (default 0.1)
-    noise_std: std of Gaussian noise (default 0.003)
-    voiced_thoreshold: F0 threshold for U/V classification (default 0)
-    flag_for_pulse: this SinGen is used inside PulseGen (default False)
-    Note: when flag_for_pulse is True, the first time step of a voiced
-        segment is always sin(np.pi) or cos(0)
-    """
-
-    def __init__(
-        self,
-        samp_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        noise_std=0.003,
-        voiced_threshold=0,
-        flag_for_pulse=False,
-    ):
-        super(SineGen, self).__init__()
-        self.sine_amp = sine_amp
-        self.noise_std = noise_std
-        self.harmonic_num = harmonic_num
-        self.dim = self.harmonic_num + 1
-        self.sampling_rate = samp_rate
-        self.voiced_threshold = voiced_threshold
-
-    def _f02uv(self, f0):
-        # generate uv signal
-        uv = torch.ones_like(f0)
-        uv = uv * (f0 > self.voiced_threshold)
-        return uv
-
-    def forward(self, f0, upp):
-        """sine_tensor, uv = forward(f0)
-        input F0: tensor(batchsize=1, length, dim=1)
-                  f0 for unvoiced steps should be 0
-        output sine_tensor: tensor(batchsize=1, length, dim)
-        output uv: tensor(batchsize=1, length, 1)
-        """
-        with torch.no_grad():
-            f0 = f0[:, None].transpose(1, 2)
-            f0_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim, device=f0.device)
-            # fundamental component
-            f0_buf[:, :, 0] = f0[:, :, 0]
-            for idx in np.arange(self.harmonic_num):
-                f0_buf[:, :, idx + 1] = f0_buf[:, :, 0] * (
-                    idx + 2
-                )  # idx + 2: the (idx+1)-th overtone, (idx+2)-th harmonic
-            rad_values = (f0_buf / self.sampling_rate) % 1  ###%1意味着n_har的乘积无法后处理优化
-            rand_ini = torch.rand(
-                f0_buf.shape[0], f0_buf.shape[2], device=f0_buf.device
-            )
-            rand_ini[:, 0] = 0
-            rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
-            tmp_over_one = torch.cumsum(rad_values, 1)  # % 1  #####%1意味着后面的cumsum无法再优化
-            tmp_over_one *= upp
-            tmp_over_one = F.interpolate(
-                tmp_over_one.transpose(2, 1),
-                scale_factor=upp,
-                mode="linear",
-                align_corners=True,
-            ).transpose(2, 1)
-            rad_values = F.interpolate(
-                rad_values.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(
-                2, 1
-            )  #######
-            tmp_over_one %= 1
-            tmp_over_one_idx = (tmp_over_one[:, 1:, :] - tmp_over_one[:, :-1, :]) < 0
-            cumsum_shift = torch.zeros_like(rad_values)
-            cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
-            sine_waves = torch.sin(
-                torch.cumsum(rad_values + cumsum_shift, dim=1) * 2 * np.pi
-            )
-            sine_waves = sine_waves * self.sine_amp
-            uv = self._f02uv(f0)
-            uv = F.interpolate(
-                uv.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(2, 1)
-            noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
-            noise = noise_amp * torch.randn_like(sine_waves)
-            sine_waves = sine_waves * uv + noise
-        return sine_waves, uv, noise
-
-
-class SourceModuleHnNSF(torch.nn.Module):
-    """SourceModule for hn-nsf
-    SourceModule(sampling_rate, harmonic_num=0, sine_amp=0.1,
-                 add_noise_std=0.003, voiced_threshod=0)
-    sampling_rate: sampling_rate in Hz
-    harmonic_num: number of harmonic above F0 (default: 0)
-    sine_amp: amplitude of sine source signal (default: 0.1)
-    add_noise_std: std of additive Gaussian noise (default: 0.003)
-        note that amplitude of noise in unvoiced is decided
-        by sine_amp
-    voiced_threshold: threhold to set U/V given F0 (default: 0)
-    Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
-    F0_sampled (batchsize, length, 1)
-    Sine_source (batchsize, length, 1)
-    noise_source (batchsize, length 1)
-    uv (batchsize, length, 1)
-    """
-
-    def __init__(
-        self,
-        sampling_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        add_noise_std=0.003,
-        voiced_threshod=0,
-        is_half=True,
-    ):
-        super(SourceModuleHnNSF, self).__init__()
-
-        self.sine_amp = sine_amp
-        self.noise_std = add_noise_std
-        self.is_half = is_half
-        # to produce sine waveforms
-        self.l_sin_gen = SineGen(
-            sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshod
-        )
-
-        # to merge source harmonics into a single excitation
-        self.l_linear = torch.nn.Linear(harmonic_num + 1, 1)
-        self.l_tanh = torch.nn.Tanh()
-
-    def forward(self, x, upp=None):
-        sine_wavs, uv, _ = self.l_sin_gen(x, upp)
-        if self.is_half:
-            sine_wavs = sine_wavs.half()
-        sine_merge = self.l_tanh(self.l_linear(sine_wavs))
-        return sine_merge, None, None  # noise, uv
-
-
-class GeneratorNSF(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels,
-        sr,
-        is_half=False,
-    ):
-        super(GeneratorNSF, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-
-        self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(upsample_rates))
-        self.m_source = SourceModuleHnNSF(
-            sampling_rate=sr, harmonic_num=0, is_half=is_half
-        )
-        self.noise_convs = nn.ModuleList()
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            c_cur = upsample_initial_channel // (2 ** (i + 1))
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-            if i + 1 < len(upsample_rates):
-                stride_f0 = np.prod(upsample_rates[i + 1 :])
-                self.noise_convs.append(
-                    Conv1d(
-                        1,
-                        c_cur,
-                        kernel_size=stride_f0 * 2,
-                        stride=stride_f0,
-                        padding=stride_f0 // 2,
-                    )
-                )
-            else:
-                self.noise_convs.append(Conv1d(1, c_cur, kernel_size=1))
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-        self.upp = np.prod(upsample_rates)
-
-    def forward(self, x, f0, g=None):
-        har_source, noi_source, uv = self.m_source(f0, self.upp)
-        har_source = har_source.transpose(1, 2)
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            x_source = self.noise_convs[i](har_source)
-            x = x + x_source
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-sr2sr = {
-    "32k": 32000,
-    "40k": 40000,
-    "48k": 48000,
-}
-
-
-class SynthesizerTrnMs256NSFsid(nn.Module):
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        gin_channels,
-        sr,
-        **kwargs
-    ):
-        super().__init__()
-        if type(sr) == type("strr"):
-            sr = sr2sr[sr]
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder256(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-        )
-        self.dec = GeneratorNSF(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-            sr=sr,
-            is_half=kwargs["is_half"],
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(
-        self, phone, phone_lengths, pitch, pitchf, y, y_lengths, ds
-    ):  # 这里ds是id，[bs,1]
-        # print(1,pitch.shape)#[bs,t]
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
-        z_p = self.flow(z, y_mask, g=g)
-        z_slice, ids_slice = commons.rand_slice_segments(
-            z, y_lengths, self.segment_size
-        )
-        # print(-1,pitchf.shape,ids_slice,self.segment_size,self.hop_length,self.segment_size//self.hop_length)
-        pitchf = commons.slice_segments2(pitchf, ids_slice, self.segment_size)
-        # print(-2,pitchf.shape,z_slice.shape)
-        o = self.dec(z_slice, pitchf, g=g)
-        return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
-    def infer(self, phone, phone_lengths, pitch, nsff0, sid, max_len=None):
-        g = self.emb_g(sid).unsqueeze(-1)
-        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
-        z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec((z * x_mask)[:, :, :max_len], nsff0, g=g)
-        return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class SynthesizerTrnMs256NSFsid_nono(nn.Module):
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        gin_channels,
-        sr=None,
-        **kwargs
-    ):
-        super().__init__()
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder256(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-            f0=False,
-        )
-        self.dec = Generator(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(self, phone, phone_lengths, y, y_lengths, ds):  # 这里ds是id，[bs,1]
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
-        z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
-        z_p = self.flow(z, y_mask, g=g)
-        z_slice, ids_slice = commons.rand_slice_segments(
-            z, y_lengths, self.segment_size
-        )
-        o = self.dec(z_slice, g=g)
-        return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
-    def infer(self, phone, phone_lengths, sid, max_len=None):
-        g = self.emb_g(sid).unsqueeze(-1)
-        m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
-        z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
-        z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec((z * x_mask)[:, :, :max_len], g=g)
-        return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class SynthesizerTrnMs256NSFsid_sim(nn.Module):
-    """
-    Synthesizer for Training
-    """
-
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        # hop_length,
-        gin_channels=0,
-        use_sdp=True,
-        **kwargs
-    ):
-        super().__init__()
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder256Sim(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-        )
-        self.dec = GeneratorNSF(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-            is_half=kwargs["is_half"],
-        )
-
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(
-        self, phone, phone_lengths, pitch, pitchf, y_lengths, ds
-    ):  # y是spec不需要了现在
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        x, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        x = self.flow(x, x_mask, g=g, reverse=True)
-        z_slice, ids_slice = commons.rand_slice_segments(
-            x, y_lengths, self.segment_size
-        )
-
-        pitchf = commons.slice_segments2(pitchf, ids_slice, self.segment_size)
-        o = self.dec(z_slice, pitchf, g=g)
-        return o, ids_slice
-
-    def infer(
-        self, phone, phone_lengths, pitch, pitchf, ds, max_len=None
-    ):  # y是spec不需要了现在
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        x, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        x = self.flow(x, x_mask, g=g, reverse=True)
-        o = self.dec((x * x_mask)[:, :, :max_len], pitchf, g=g)
-        return o, o
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminator, self).__init__()
-        periods = [2, 3, 5, 7, 11, 17]
-        # periods = [3, 5, 7, 11, 17, 23, 37]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [
-            DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
-        ]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []  #
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            # for j in range(len(fmap_r)):
-            #     print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class DiscriminatorS(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(DiscriminatorS, self).__init__()
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(Conv1d(1, 16, 15, 1, padding=7)),
-                norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
-                norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
-                norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
-                norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
-                norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
-            ]
-        )
-        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x):
-        fmap = []
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.use_spectral_norm = use_spectral_norm
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(
-                    Conv2d(
-                        1,
-                        32,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        32,
-                        128,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        128,
-                        512,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        512,
-                        1024,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        1024,
-                        1024,
-                        (kernel_size, 1),
-                        1,
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-            ]
-        )
-        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0:  # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
diff --git a/spaces/flatindo/scaler/realesrgan/train.py b/spaces/flatindo/scaler/realesrgan/train.py
deleted file mode 100644
index 8a9cec9ed80d9f362984779548dcec921a636a04..0000000000000000000000000000000000000000
--- a/spaces/flatindo/scaler/realesrgan/train.py
+++ /dev/null
@@ -1,11 +0,0 @@
-# flake8: noqa
-import os.path as osp
-from basicsr.train import train_pipeline
-
-import realesrgan.archs
-import realesrgan.data
-import realesrgan.models
-
-if __name__ == '__main__':
-    root_path = osp.abspath(osp.join(__file__, osp.pardir, osp.pardir))
-    train_pipeline(root_path)
diff --git a/spaces/flax-community/Multilingual-VQA/session.py b/spaces/flax-community/Multilingual-VQA/session.py
deleted file mode 100644
index 890a29bafd97091f7163df306d58982decb0a11a..0000000000000000000000000000000000000000
--- a/spaces/flax-community/Multilingual-VQA/session.py
+++ /dev/null
@@ -1,89 +0,0 @@
-#
-# Code for managing session state, which is needed for multi-input forms
-# See https://github.com/streamlit/streamlit/issues/1557
-#
-# This code is taken from
-# https://gist.github.com/okld/0aba4869ba6fdc8d49132e6974e2e662
-#
-from streamlit.hashing import _CodeHasher
-from streamlit.report_thread import get_report_ctx
-from streamlit.server.server import Server
-
-
-class _SessionState:
-    def __init__(self, session, hash_funcs):
-        """Initialize SessionState instance."""
-        self.__dict__["_state"] = {
-            "data": {},
-            "hash": None,
-            "hasher": _CodeHasher(hash_funcs),
-            "is_rerun": False,
-            "session": session,
-        }
-
-    def __call__(self, **kwargs):
-        """Initialize state data once."""
-        for item, value in kwargs.items():
-            if item not in self._state["data"]:
-                self._state["data"][item] = value
-
-    def __getitem__(self, item):
-        """Return a saved state value, None if item is undefined."""
-        return self._state["data"].get(item, None)
-
-    def __getattr__(self, item):
-        """Return a saved state value, None if item is undefined."""
-        return self._state["data"].get(item, None)
-
-    def __setitem__(self, item, value):
-        """Set state value."""
-        self._state["data"][item] = value
-
-    def __setattr__(self, item, value):
-        """Set state value."""
-        self._state["data"][item] = value
-
-    def clear(self):
-        """Clear session state and request a rerun."""
-        self._state["data"].clear()
-        self._state["session"].request_rerun()
-
-    def sync(self):
-        """
-        Rerun the app with all state values up to date from the beginning to
-        fix rollbacks.
-        """
-        data_to_bytes = self._state["hasher"].to_bytes(self._state["data"], None)
-
-        # Ensure to rerun only once to avoid infinite loops
-        # caused by a constantly changing state value at each run.
-        #
-        # Example: state.value += 1
-        if self._state["is_rerun"]:
-            self._state["is_rerun"] = False
-
-        elif self._state["hash"] is not None:
-            if self._state["hash"] != data_to_bytes:
-                self._state["is_rerun"] = True
-                self._state["session"].request_rerun()
-
-        self._state["hash"] = data_to_bytes
-
-
-def _get_session():
-    session_id = get_report_ctx().session_id
-    session_info = Server.get_current()._get_session_info(session_id)
-
-    if session_info is None:
-        raise RuntimeError("Couldn't get your Streamlit Session object.")
-
-    return session_info.session
-
-
-def _get_state(hash_funcs=None):
-    session = _get_session()
-
-    if not hasattr(session, "_custom_session_state"):
-        session._custom_session_state = _SessionState(session, hash_funcs)
-
-    return session._custom_session_state
diff --git a/spaces/floriankrempl/mtg_rules_bot/app.py b/spaces/floriankrempl/mtg_rules_bot/app.py
deleted file mode 100644
index 45abd4707a937b60ae3b3966beb55c3bda6e4184..0000000000000000000000000000000000000000
--- a/spaces/floriankrempl/mtg_rules_bot/app.py
+++ /dev/null
@@ -1,32 +0,0 @@
-import gradio
-from pathlib import Path
-
-from mtg.bot import MagicGPT
-from mtg.data_handler import CardDB
-from mtg.bot.chat import create_chat_model
-from mtg.bot.chat_history import ChatHistory
-
-all_cards_file = Path("data/cards/scryfall_all_cards_with_rulings.json")
-vector_db_file = Path("data/artifacts/card_vector_db.p")
-
-card_db = CardDB(all_cards_file=all_cards_file, vector_db_file=vector_db_file)
-chat_history = ChatHistory()
-llm_chain = create_chat_model(
-    model="gpt-3.5-turbo", temperature=1, max_token_limit=2000
-)
-magic_bot = MagicGPT(llm_chain=llm_chain, card_db=card_db, chat_history=chat_history)
-
-# creates a new Blocks app and assigns it to the variable demo.
-with gradio.Blocks() as ui:
-    # creates a new Chatbot instance and assigns it to the variable chatbot.
-    chatbot = gradio.Chatbot()
-
-    # creates a new Row component, which is a container for other components.
-    with gradio.Row():
-        txt = gradio.Textbox(show_label=False, placeholder="Enter text and press enter")
-    txt.submit(magic_bot.ask, txt, chatbot)
-    # txt.submit(None, None, txt, _js="() => {''}")
-    with gradio.Row():
-        clear_btn = gradio.ClearButton([chatbot, txt], value="Start new Conversation")
-    clear_btn.click(magic_bot.clear_memory)
-ui.launch()
diff --git a/spaces/flowers-team/SocialAISchool/gym-minigrid/gym_minigrid/backup_envs/twodoorsintent.py b/spaces/flowers-team/SocialAISchool/gym-minigrid/gym_minigrid/backup_envs/twodoorsintent.py
deleted file mode 100644
index 5602c331eb581d646a26f9d8c3b467903e04d80e..0000000000000000000000000000000000000000
--- a/spaces/flowers-team/SocialAISchool/gym-minigrid/gym_minigrid/backup_envs/twodoorsintent.py
+++ /dev/null
@@ -1,274 +0,0 @@
-import numpy as np
-
-from gym_minigrid.minigrid import *
-from gym_minigrid.register import register
- 
-import time
-from collections import deque
-
-
-class Peer(NPC):
-    """
-    A dancing NPC that the agent has to copy
-    """
-
-    def __init__(self, color, name, env):
-        super().__init__(color)
-        self.name = name
-        self.npc_dir = 1  # NPC initially looks downward
-        self.npc_type = 0
-        self.env = env
-        self.npc_actions = []
-        self.dancing_step_idx = 0
-        self.actions = MiniGridEnv.Actions
-        self.add_npc_direction = True
-        self.available_moves = [self.rotate_left, self.rotate_right, self.go_forward, self.toggle_action]
-
-        selected_door_id = self.env._rand_elem([0, 1])
-        self.selected_door_pos = [self.env.door_pos_top, self.env.door_pos_bottom][selected_door_id]
-        self.selected_door = [self.env.door_top, self.env.door_bottom][selected_door_id]
-
-    def step(self):
-
-        if all(self.front_pos == self.selected_door_pos):
-            # in front of door
-            if self.selected_door.is_open:
-                self.go_forward()
-
-        else:
-            if (self.cur_pos[0] == self.selected_door_pos[0]) or (self.cur_pos[1] == self.selected_door_pos[1]):
-                # is either in the correct row on in the correct column
-                next_wanted_position = self.selected_door_pos
-            else:
-                # choose the midpoint
-                for cand_x, cand_y in [
-                    (self.cur_pos[0], self.selected_door_pos[1]),
-                    (self.selected_door_pos[0], self.cur_pos[1])
-                ]:
-                    print("wX:", self.env.wall_x)
-                    print("wY:", self.env.wall_y)
-                    if (
-                            cand_x > 0 and cand_x < self.env.wall_x
-                    ) and (
-                            cand_y > 0 and cand_y < self.env.wall_y
-                    ):
-                        next_wanted_position = (cand_x, cand_y)
-                    print("wanted_pos:", next_wanted_position)
-
-            if self.cur_pos[1] == next_wanted_position[1]:
-                # same y
-                if self.cur_pos[0] < next_wanted_position[0]:
-                    wanted_dir = 0
-                else:
-                    wanted_dir = 2
-                if self.npc_dir == wanted_dir:
-                    self.go_forward()
-
-                else:
-                    self.rotate_left()
-
-            elif self.cur_pos[0] == next_wanted_position[0]:
-                # same x
-                if self.cur_pos[1] < next_wanted_position[1]:
-                    wanted_dir = 1
-                else:
-                    wanted_dir = 3
-
-                if self.npc_dir == wanted_dir:
-                    self.go_forward()
-
-                else:
-                    self.rotate_left()
-            else:
-                raise ValueError("Something is wrong.")
-
-
-class TwoDoorsIntentGrammar(object):
-
-    templates = ["Move your", "Shake your"]
-    things = ["body", "head"]
-
-    grammar_action_space = spaces.MultiDiscrete([len(templates), len(things)])
-
-    @classmethod
-    def construct_utterance(cls, action):
-        return cls.templates[int(action[0])] + " " + cls.things[int(action[1])] + " "
-
-
-class TwoDoorsIntentEnv(MultiModalMiniGridEnv):
-    """
-    Environment in which the agent is instructed to go to a given object
-    named using an English text string
-    """
-
-    def __init__(
-        self,
-        size=5,
-        diminished_reward=True,
-        step_penalty=False,
-        knowledgeable=False,
-    ):
-        assert size >= 5
-        self.empty_symbol = "NA \n"
-        self.diminished_reward = diminished_reward
-        self.step_penalty = step_penalty
-        self.knowledgeable = knowledgeable
-
-        super().__init__(
-            grid_size=size,
-            max_steps=5*size**2,
-            # Set this to True for maximum speed
-            see_through_walls=True,
-            actions=MiniGridEnv.Actions,
-            action_space=spaces.MultiDiscrete([
-                len(MiniGridEnv.Actions),
-                *TwoDoorsIntentGrammar.grammar_action_space.nvec
-            ]),
-            add_npc_direction=True
-        )
-
-        print({
-            "size": size,
-            "diminished_reward": diminished_reward,
-            "step_penalty": step_penalty,
-        })
-
-    def _gen_grid(self, width, height):
-        # Create the grid
-        self.grid = Grid(width, height, nb_obj_dims=4)
-
-        # Randomly vary the room width and height
-        width = self._rand_int(5, width+1)
-        height = self._rand_int(5, height+1)
-
-        self.wall_x = width-1
-        self.wall_y = height-1
-
-        # Generate the surrounding walls
-        self.grid.wall_rect(0, 0, width, height)
-
-        # door top
-        door_color_top = self._rand_elem(COLOR_NAMES)
-        self.door_pos_top = (width-1, 1)
-        self.door_top = Door(door_color_top)
-        self.grid.set(*self.door_pos_top, self.door_top)
-
-        # switch top
-        self.switch_pos_top = (0, 1)
-        self.switch_top = Switch(door_color_top, lockable_object=self.door_top)
-        self.grid.set(*self.switch_pos_top, self.switch_top)
-
-        # door bottom
-        door_color_bottom = self._rand_elem(COLOR_NAMES)
-        self.door_pos_bottom = (width-1, height-2)
-        self.door_bottom = Door(door_color_bottom)
-        self.grid.set(*self.door_pos_bottom, self.door_bottom)
-
-        # switch bottom
-        self.switch_pos_bottom = (0, height-2)
-        self.switch_bottom = Switch(door_color_bottom, lockable_object=self.door_bottom)
-        self.grid.set(*self.switch_pos_bottom, self.switch_bottom)
-
-        # Set a randomly coloured Dancer NPC
-        color = self._rand_elem(COLOR_NAMES)
-        self.peer = Peer(color, "Jill", self)
-
-        # Place it on the middle left side of the room
-        peer_pos = np.array((self._rand_int(1, width - 1), self._rand_int(1, height - 1)))
-
-        self.grid.set(*peer_pos, self.peer)
-        self.peer.init_pos = peer_pos
-        self.peer.cur_pos = peer_pos
-
-        # Randomize the agent's start position and orientation
-        self.place_agent(size=(width, height))
-
-        # Generate the mission string
-        self.mission = 'watch dancer and repeat his moves afterwards'
-
-        # Dummy beginning string
-        self.beginning_string = "This is what you hear. \n"
-        self.utterance = self.beginning_string
-
-        # utterance appended at the end of each step
-        self.utterance_history = ""
-
-        # used for rendering
-        self.conversation = self.utterance
-
-    def step(self, action):
-        p_action = action[0]
-        utterance_action = action[1:]
-
-        obs, reward, done, info = super().step(p_action)
-        self.peer.step()
-
-        if np.isnan(p_action):
-            pass
-
-        if p_action == self.actions.done:
-            done = True
-
-        elif all(self.agent_pos == self.door_pos_top):
-            done = True
-
-        elif all(self.agent_pos == self.door_pos_bottom):
-            done = True
-
-        elif all([self.switch_top.is_on, self.switch_bottom.is_on]):
-            # if both switches are on no reward is given and episode ends
-            done = True
-
-        elif all(self.peer.cur_pos == self.peer.selected_door_pos):
-            reward = self._reward()
-            done = True
-
-        # discount
-        if self.step_penalty:
-            reward = reward - 0.01
-
-        # fill observation with text
-        self.append_existing_utterance_to_history()
-        obs = self.add_utterance_to_observation(obs)
-        self.reset_utterance()
-        return obs, reward, done, info
-
-    def _reward(self):
-        if self.diminished_reward:
-            return super()._reward()
-        else:
-            return 1.0
-
-    def render(self, *args, **kwargs):
-        obs = super().render(*args, **kwargs)
-        print("conversation:\n", self.conversation)
-        print("utterance_history:\n", self.utterance_history)
-        self.window.set_caption(self.conversation, [self.peer.name])
-        return obs
-
-
-class TwoDoorsIntent8x8Env(TwoDoorsIntentEnv):
-    def __init__(self):
-        super().__init__(size=8)
-
-
-class TwoDoorsIntent6x6Env(TwoDoorsIntentEnv):
-    def __init__(self):
-        super().__init__(size=6)
-
-
-
-register(
-    id='MiniGrid-TwoDoorsIntent-5x5-v0',
-    entry_point='gym_minigrid.envs:TwoDoorsIntentEnv'
-)
-
-register(
-    id='MiniGrid-TwoDoorsIntent-6x6-v0',
-    entry_point='gym_minigrid.envs:TwoDoorsIntent6x6Env'
-)
-
-register(
-    id='MiniGrid-TwoDoorsIntent-8x8-v0',
-    entry_point='gym_minigrid.envs:TwoDoorsIntent8x8Env'
-)
diff --git a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmcv/cnn/bricks/activation.py b/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmcv/cnn/bricks/activation.py
deleted file mode 100644
index cab2712287d5ef7be2f079dcb54a94b96394eab5..0000000000000000000000000000000000000000
--- a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmcv/cnn/bricks/activation.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from annotator.uniformer.mmcv.utils import TORCH_VERSION, build_from_cfg, digit_version
-from .registry import ACTIVATION_LAYERS
-
-for module in [
-        nn.ReLU, nn.LeakyReLU, nn.PReLU, nn.RReLU, nn.ReLU6, nn.ELU,
-        nn.Sigmoid, nn.Tanh
-]:
-    ACTIVATION_LAYERS.register_module(module=module)
-
-
-@ACTIVATION_LAYERS.register_module(name='Clip')
-@ACTIVATION_LAYERS.register_module()
-class Clamp(nn.Module):
-    """Clamp activation layer.
-
-    This activation function is to clamp the feature map value within
-    :math:`[min, max]`. More details can be found in ``torch.clamp()``.
-
-    Args:
-        min (Number | optional): Lower-bound of the range to be clamped to.
-            Default to -1.
-        max (Number | optional): Upper-bound of the range to be clamped to.
-            Default to 1.
-    """
-
-    def __init__(self, min=-1., max=1.):
-        super(Clamp, self).__init__()
-        self.min = min
-        self.max = max
-
-    def forward(self, x):
-        """Forward function.
-
-        Args:
-            x (torch.Tensor): The input tensor.
-
-        Returns:
-            torch.Tensor: Clamped tensor.
-        """
-        return torch.clamp(x, min=self.min, max=self.max)
-
-
-class GELU(nn.Module):
-    r"""Applies the Gaussian Error Linear Units function:
-
-    .. math::
-        \text{GELU}(x) = x * \Phi(x)
-    where :math:`\Phi(x)` is the Cumulative Distribution Function for
-    Gaussian Distribution.
-
-    Shape:
-        - Input: :math:`(N, *)` where `*` means, any number of additional
-          dimensions
-        - Output: :math:`(N, *)`, same shape as the input
-
-    .. image:: scripts/activation_images/GELU.png
-
-    Examples::
-
-        >>> m = nn.GELU()
-        >>> input = torch.randn(2)
-        >>> output = m(input)
-    """
-
-    def forward(self, input):
-        return F.gelu(input)
-
-
-if (TORCH_VERSION == 'parrots'
-        or digit_version(TORCH_VERSION) < digit_version('1.4')):
-    ACTIVATION_LAYERS.register_module(module=GELU)
-else:
-    ACTIVATION_LAYERS.register_module(module=nn.GELU)
-
-
-def build_activation_layer(cfg):
-    """Build activation layer.
-
-    Args:
-        cfg (dict): The activation layer config, which should contain:
-            - type (str): Layer type.
-            - layer args: Args needed to instantiate an activation layer.
-
-    Returns:
-        nn.Module: Created activation layer.
-    """
-    return build_from_cfg(cfg, ACTIVATION_LAYERS)
diff --git a/spaces/giulio98/codebleu/parsercode/utils.py b/spaces/giulio98/codebleu/parsercode/utils.py
deleted file mode 100644
index bc39f9fd083f9da8e85a4793acd2f888ba47f614..0000000000000000000000000000000000000000
--- a/spaces/giulio98/codebleu/parsercode/utils.py
+++ /dev/null
@@ -1,101 +0,0 @@
-# Copyright (c) Microsoft Corporation. 
-# Licensed under the MIT license.
-
-import re
-from io import StringIO
-import  tokenize
-def remove_comments_and_docstrings(source,lang):
-    if lang in ['python']:
-        """
-        Returns 'source' minus comments and docstrings.
-        """
-        io_obj = StringIO(source)
-        out = ""
-        prev_toktype = tokenize.INDENT
-        last_lineno = -1
-        last_col = 0
-        for tok in tokenize.generate_tokens(io_obj.readline):
-            token_type = tok[0]
-            token_string = tok[1]
-            start_line, start_col = tok[2]
-            end_line, end_col = tok[3]
-            ltext = tok[4]
-            if start_line > last_lineno:
-                last_col = 0
-            if start_col > last_col:
-                out += (" " * (start_col - last_col))
-            # Remove comments:
-            if token_type == tokenize.COMMENT:
-                pass
-            # This series of conditionals removes docstrings:
-            elif token_type == tokenize.STRING:
-                if prev_toktype != tokenize.INDENT:
-            # This is likely a docstring; double-check we're not inside an operator:
-                    if prev_toktype != tokenize.NEWLINE:
-                        if start_col > 0:
-                            out += token_string
-            else:
-                out += token_string
-            prev_toktype = token_type
-            last_col = end_col
-            last_lineno = end_line
-        temp=[]
-        for x in out.split('\n'):
-            if x.strip()!="":
-                temp.append(x)
-        return '\n'.join(temp)
-    elif lang in ['ruby']:
-        return source
-    else:
-        def replacer(match):
-            s = match.group(0)
-            if s.startswith('/'):
-                return " " # note: a space and not an empty string
-            else:
-                return s
-        pattern = re.compile(
-            r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"',
-            re.DOTALL | re.MULTILINE
-        )
-        temp=[]
-        for x in re.sub(pattern, replacer, source).split('\n'):
-            if x.strip()!="":
-                temp.append(x)
-        return '\n'.join(temp)
-
-def tree_to_token_index(root_node):
-    if (len(root_node.children)==0 or root_node.type in ['string_literal','string','character_literal']) and root_node.type!='comment':
-        return [(root_node.start_point,root_node.end_point)]
-    else:
-        code_tokens=[]
-        for child in root_node.children:
-            code_tokens+=tree_to_token_index(child)
-        return code_tokens
-    
-def tree_to_variable_index(root_node,index_to_code):
-    if (len(root_node.children)==0 or root_node.type in ['string_literal','string','character_literal']) and root_node.type!='comment':
-        index=(root_node.start_point,root_node.end_point)
-        _,code=index_to_code[index]
-        if root_node.type!=code:
-            return [(root_node.start_point,root_node.end_point)]
-        else:
-            return []
-    else:
-        code_tokens=[]
-        for child in root_node.children:
-            code_tokens+=tree_to_variable_index(child,index_to_code)
-        return code_tokens    
-
-def index_to_code_token(index,code):
-    start_point=index[0]
-    end_point=index[1]
-    if start_point[0]==end_point[0]:
-        s=code[start_point[0]][start_point[1]:end_point[1]]
-    else:
-        s=""
-        s+=code[start_point[0]][start_point[1]:]
-        for i in range(start_point[0]+1,end_point[0]):
-            s+=code[i]
-        s+=code[end_point[0]][:end_point[1]]   
-    return s
-   
\ No newline at end of file
diff --git a/spaces/gotiQspiryo/whisper-ui/examples/FIFA 20 Crack Torrent Dont Miss This Amazing Offer.md b/spaces/gotiQspiryo/whisper-ui/examples/FIFA 20 Crack Torrent Dont Miss This Amazing Offer.md
deleted file mode 100644
index 5354014606e37bd98fc3aecbc87c643143e491df..0000000000000000000000000000000000000000
--- a/spaces/gotiQspiryo/whisper-ui/examples/FIFA 20 Crack Torrent Dont Miss This Amazing Offer.md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>FIFA 20 Crack Torrent Full Free Download Here!</h2><br /><p><b><b>Download</b> &hArr; <a href="https://urlgoal.com/2uyMLD">https://urlgoal.com/2uyMLD</a></b></p><br /><br />
-<br />
- aaccfb2cb3<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/gradio/HuBERT/examples/flores101/README.md b/spaces/gradio/HuBERT/examples/flores101/README.md
deleted file mode 100644
index 635c13f40bd0ccab704735bc5c26ea0192ea98cd..0000000000000000000000000000000000000000
--- a/spaces/gradio/HuBERT/examples/flores101/README.md
+++ /dev/null
@@ -1,223 +0,0 @@
-<p align="center">
-<img src="flores_logo.png" width="500">
-</p>
-
-# Flores101: Large-Scale Multilingual Machine Translation
-
-## Introduction
-
-Baseline pretrained models for small and large tracks of WMT 21 Large-Scale Multilingual Machine Translation competition.
-
-Flores Task at WMT 21: http://www.statmt.org/wmt21/large-scale-multilingual-translation-task.html
-
-Flores announement blog post: https://ai.facebook.com/blog/flores-researchers-kick-off-multilingual-translation-challenge-at-wmt-and-call-for-compute-grants/
-
-
-
-## Pretrained models
-
-Model | Num layers | Embed dimension | FFN dimension| Vocab Size | #params | Download
----|---|---|---|---|---|---
-`flores101_mm100_615M` | 12 | 1024 | 4096 | 256,000 | 615M | https://dl.fbaipublicfiles.com/flores101/pretrained_models/flores101_mm100_615M.tar.gz
-`flores101_mm100_175M` | 6 | 512 | 2048 | 256,000 | 175M | https://dl.fbaipublicfiles.com/flores101/pretrained_models/flores101_mm100_175M.tar.gz
-
-
-These models are trained similar to [M2M-100](https://arxiv.org/abs/2010.11125) with additional support for the languages that are part of the WMT Large-Scale Multilingual Machine Translation track. Full list of languages can be found at the bottom.
-
-
-## Example Generation code
-
-### Download model, sentencepiece vocab
-
-```bash
-fairseq=/path/to/fairseq
-cd $fairseq
-
-# Download 615M param model.
-wget https://dl.fbaipublicfiles.com/flores101/pretrained_models/flores101_mm100_615M.tar.gz
-
-# Extract 
-tar -xvzf flores101_mm100_615M.tar.gz
-```
-
-### Encode using our SentencePiece Model
-Note: Install SentencePiece from [here](https://github.com/google/sentencepiece)
-
-
-```bash
-fairseq=/path/to/fairseq
-cd $fairseq
-
-# Download example dataset From German to French
-sacrebleu --echo src -l de-fr -t wmt19 | head -n 20 > raw_input.de-fr.de
-sacrebleu --echo ref -l de-fr -t wmt19 | head -n 20 > raw_input.de-fr.fr
-
-for lang in de fr ; do
-    python scripts/spm_encode.py \
-        --model flores101_mm100_615M/sentencepiece.bpe.model \
-        --output_format=piece \
-        --inputs=raw_input.de-fr.${lang} \
-        --outputs=spm.de-fr.${lang}
-done
-```
-
-### Binarization
-
-```bash
-fairseq-preprocess \
-    --source-lang de --target-lang fr \
-    --testpref spm.de-fr \
-    --thresholdsrc 0 --thresholdtgt 0 \
-    --destdir data_bin \
-    --srcdict flores101_mm100_615M/dict.txt --tgtdict flores101_mm100_615M/dict.txt
-```
-
-### Generation 
-
-
-```bash
-fairseq-generate \
-    data_bin \
-    --batch-size 1 \
-    --path flores101_mm100_615M/model.pt \
-    --fixed-dictionary flores101_mm100_615M/dict.txt \
-    -s de -t fr \
-    --remove-bpe 'sentencepiece' \
-    --beam 5 \
-    --task translation_multi_simple_epoch \
-    --lang-pairs flores101_mm100_615M/language_pairs.txt \
-    --decoder-langtok --encoder-langtok src \
-    --gen-subset test \
-    --fp16 \
-    --dataset-impl mmap \
-    --distributed-world-size 1 --distributed-no-spawn
-```
-
-### Supported Languages and lang code
-
-Language | lang code
----|---
-Akrikaans | af
-Amharic | am
-Arabic | ar
-Assamese | as
-Asturian | ast
-Aymara | ay
-Azerbaijani | az
-Bashkir | ba
-Belarusian | be
-Bulgarian | bg
-Bengali | bn
-Breton | br
-Bosnian | bs
-Catalan | ca
-Cebuano | ceb
-Chokwe | cjk
-Czech | cs
-Welsh | cy
-Danish | da
-German | de
-Dyula| dyu
-Greek | el
-English | en
-Spanish | es
-Estonian | et
-Persian | fa
-Fulah | ff
-Finnish | fi
-French | fr
-Western Frisian | fy
-Irish | ga
-Scottish Gaelic | gd
-Galician | gl
-Gujarati | gu
-Hausa | ha
-Hebrew | he
-Hindi | hi
-Croatian | hr
-Haitian Creole | ht
-Hungarian | hu
-Armenian | hy
-Indonesian | id
-Igbo | ig
-Iloko | ilo
-Icelandic | is
-Italian | it
-Japanese | ja
-Javanese | jv
-Georgian | ka
-Kachin | kac
-Kamba | kam
-Kabuverdianu | kea
-Kongo | kg
-Kazakh | kk
-Central Khmer | km
-Kimbundu | kmb
-Northern Kurdish | kmr
-Kannada | kn
-Korean | ko
-Kurdish | ku
-Kyrgyz | ky
-Luxembourgish | lb
-Ganda | lg
-Lingala | ln
-Lao | lo
-Lithuanian | lt
-Luo | luo
-Latvian | lv
-Malagasy | mg
-Maori | mi
-Macedonian | mk
-Malayalam | ml
-Mongolian | mn
-Marathi | mr
-Malay | ms
-Maltese | mt
-Burmese | my
-Nepali | ne
-Dutch | nl
-Norwegian | no
-Northern Sotho | ns
-Nyanja | ny
-Occitan | oc
-Oromo | om
-Oriya | or
-Punjabi | pa
-Polish | pl
-Pashto | ps
-Portuguese | pt
-Quechua | qu
-Romanian | ro
-Russian | ru
-Sindhi | sd
-Shan | shn
-Sinhala | si
-Slovak | sk
-Slovenian | sl
-Shona | sn
-Somali | so
-Albanian | sq
-Serbian | sr
-Swati | ss
-Sundanese | su
-Swedish | sv
-Swahili | sw
-Tamil | ta
-Telugu | te
-Tajik | tg
-Thai | th
-Tigrinya | ti
-Tagalog | tl
-Tswana | tn
-Turkish | tr
-Ukrainian | uk
-Umbundu | umb
-Urdu | ur
-Uzbek | uz
-Vietnamese | vi
-Wolof | wo
-Xhosa | xh
-Yiddish | yi
-Yoruba | yo
-Chinese| zh
-Zulu | zu
diff --git a/spaces/gradio/HuBERT/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select.py b/spaces/gradio/HuBERT/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select.py
deleted file mode 100644
index 1122c88c1964d8beead63bc8dfe21d41602b83bc..0000000000000000000000000000000000000000
--- a/spaces/gradio/HuBERT/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select.py
+++ /dev/null
@@ -1,135 +0,0 @@
-"""
-Implement unsupervised metric for decoding hyperparameter selection:
-    $$ alpha * LM_PPL + ViterbitUER(%) * 100 $$
-"""
-import argparse
-import logging
-import math
-import sys
-
-import kenlm
-import editdistance
-from g2p_en import G2p
-
-logging.root.setLevel(logging.INFO)
-logging.basicConfig(stream=sys.stdout, level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-def get_parser():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("ref_tra", help="reference pseudo labels")
-    parser.add_argument("hyp_tra", help="decoded pseudo labels to be assess")
-    parser.add_argument("--kenlm_path", default="/checkpoint/abaevski/data/speech/libri/librispeech_lm_novox.phnc_o5.bin", help="")
-    parser.add_argument("--uppercase", action="store_true", help="")
-    parser.add_argument("--skipwords", default="", help="")
-    parser.add_argument("--gt_tra", default="", help="ground truth pseudo labels for computing oracle WER")
-    parser.add_argument("--min_vt_uer", default=0.0, type=float)
-    parser.add_argument("--phonemize", action="store_true", help="phonemize word hypotheses, used when reference is phone transcript")
-    parser.add_argument("--phonemize_lexicon", default="", type=str, help="use a lexicon for phonemizing")
-    return parser
-
-def load_tra(tra_path):
-    with open(tra_path, "r") as f:
-        uid_to_tra = {}
-        for line in f:
-            toks = line.rstrip().split()
-            uid, tra = toks[0], " ".join(toks[1:])
-            uid_to_tra[uid] = tra
-    logger.debug(f"loaded {len(uid_to_tra)} utterances from {tra_path}")
-    return uid_to_tra
-
-def load_lex(lex_path):
-    with open(lex_path, "r") as f:
-        w2p = {}
-        for line in f:
-            w, p = line.rstrip().split(None, 1)
-            w2p[w] = p.split()
-    return w2p
-            
-def compute_wer(ref_uid_to_tra, hyp_uid_to_tra, g2p, g2p_dict):
-    d_cnt = 0
-    w_cnt = 0
-    w_cnt_h = 0
-    for uid in hyp_uid_to_tra:
-        ref = ref_uid_to_tra[uid].split()
-        if g2p_dict is not None:
-            hyp = []
-            for word in hyp_uid_to_tra[uid].split():
-                if word in g2p_dict:
-                    hyp = hyp + g2p_dict[word]
-                else:
-                    logger.warning(f"{word} not in g2p_dict")
-        elif g2p is not None:
-            hyp = g2p(hyp_uid_to_tra[uid])
-            hyp = [p for p in hyp if p != "'" and p != " "]
-            hyp = [p[:-1] if p[-1].isnumeric() else p for p in hyp]
-        else:
-            hyp = hyp_uid_to_tra[uid].split()
-        logger.debug((
-            f"======================\n"
-            f"HYP: {' '.join(hyp)}\n"
-            f"REF: {' '.join(ref)}"
-        ))
-        d_cnt += editdistance.eval(ref, hyp)
-        w_cnt += len(ref)
-        w_cnt_h += len(hyp)
-    wer = float(d_cnt) / w_cnt
-    logger.debug((
-        f"wer = {wer*100:.2f}%; num. of ref words = {w_cnt}; "
-        f"num. of hyp words = {w_cnt_h}; num. of sentences = {len(ref_uid_to_tra)}"
-    ))
-    return wer
-
-def compute_lm_ppl(hyp_uid_to_tra, score_fn):
-    lm_score = 0.
-    w_cnt = 0
-    for hyp in hyp_uid_to_tra.values():
-        cur_score = score_fn(hyp)
-        cur_cnt = len(hyp.split()) + 1  # plus one for </s>
-        lm_score += cur_score
-        w_cnt += cur_cnt
-        logger.debug((
-            f"======================\n"
-            f"score sum/avg = {cur_score:.2f}/{cur_score/cur_cnt:.2f}\n"
-            f"hyp = {hyp}"
-        ))
-    lm_ppl = math.pow(10, -lm_score / w_cnt)
-    logger.debug(f"lm ppl = {lm_ppl:.2f}; num. of words = {w_cnt}")
-    return lm_ppl
-
-def main():
-    args = get_parser().parse_args()
-    logger.debug(f"Args: {args}")
-    
-    ref_uid_to_tra = load_tra(args.ref_tra)
-    hyp_uid_to_tra = load_tra(args.hyp_tra)
-    assert not bool(set(hyp_uid_to_tra.keys()) - set(ref_uid_to_tra.keys()))
-
-    lm = kenlm.Model(args.kenlm_path)
-    skipwords = set(args.skipwords.split(","))
-    def compute_lm_score(s):
-        s = " ".join(w for w in s.split() if w not in skipwords)
-        s = s.upper() if args.uppercase else s
-        return lm.score(s)
-
-    g2p, g2p_dict = None, None
-    if args.phonemize:
-        if args.phonemize_lexicon:
-            g2p_dict = load_lex(args.phonemize_lexicon)
-        else:
-            g2p = G2p()
-
-    wer = compute_wer(ref_uid_to_tra, hyp_uid_to_tra, g2p, g2p_dict)
-    lm_ppl = compute_lm_ppl(hyp_uid_to_tra, compute_lm_score)
-    
-    gt_wer = -math.inf
-    if args.gt_tra:
-        gt_uid_to_tra = load_tra(args.gt_tra)
-        gt_wer = compute_wer(gt_uid_to_tra, hyp_uid_to_tra, None, None)
-
-    score = math.log(lm_ppl) * max(wer, args.min_vt_uer)
-    logging.info(f"{args.hyp_tra}: score={score:.4f}; wer={wer*100:.2f}%; lm_ppl={lm_ppl:.4f}; gt_wer={gt_wer*100:.2f}%")
-
-if __name__ == "__main__":
-    main()
diff --git a/spaces/gradio/HuBERT/examples/wav2vec/unsupervised/scripts/normalize_text.py b/spaces/gradio/HuBERT/examples/wav2vec/unsupervised/scripts/normalize_text.py
deleted file mode 100644
index 9d0ffeb27d038a6b82aaf0f6bdf208af565663f6..0000000000000000000000000000000000000000
--- a/spaces/gradio/HuBERT/examples/wav2vec/unsupervised/scripts/normalize_text.py
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import regex
-import sys
-
-
-def main():
-    filter_r = regex.compile(r"[^\p{L}\p{N}\p{M}\' \-]")
-
-    for line in sys.stdin:
-        line = line.strip()
-        line = filter_r.sub(" ", line)
-        line = " ".join(line.split())
-        print(line)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/spaces/gradio/fake_diffusion/README.md b/spaces/gradio/fake_diffusion/README.md
deleted file mode 100644
index 7c64375802ec0c4abd8126690744817b8084bc8b..0000000000000000000000000000000000000000
--- a/spaces/gradio/fake_diffusion/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
----
-title: fake_diffusion 
-emoji: 🔥
-colorFrom: indigo
-colorTo: indigo
-sdk: gradio
-sdk_version: 4.1.2
-app_file: run.py
-pinned: false
-hf_oauth: true
----
diff --git a/spaces/gradio/gpt-neo/models/layers.py b/spaces/gradio/gpt-neo/models/layers.py
deleted file mode 100644
index 27ff4a93911377c0f55dd70d12e6fd4e8b151db7..0000000000000000000000000000000000000000
--- a/spaces/gradio/gpt-neo/models/layers.py
+++ /dev/null
@@ -1,357 +0,0 @@
-import mesh_tensorflow as mtf
-import tensorflow.compat.v1 as tf
-import math
-import mesh_tensorflow.transformer as mtf_transformer
-
-from models.activations import get_activation_fn
-
-
-# --------------------------------------------------------------------------------
-# LAYERS:
-
-sentinel = object()
-
-
-def exists(x):
-    return x is not None
-
-
-def identity(x, *args, **kwargs):
-    return x
-
-
-def is_incremental_inference(context):
-    return exists(context) and context.mode == "incremental"
-
-
-def norm(x, axis, epsilon=1e-8):
-    x -= mtf.reduce_mean(x, reduced_dim=axis, name="norm_reduce_mean_u")
-    s = mtf.reduce_mean(mtf.square(x), reduced_dim=axis, name="norm_reduce_mean_s")
-    return x * mtf.rsqrt(s + epsilon)
-
-
-def rezero(x, scope, dtype):
-    with tf.variable_scope(scope):
-        g = mtf.get_variable(x.mesh, "g", [], initializer=tf.constant_initializer(0), dtype=dtype)
-        return x * g
-
-
-def scale_norm(x, scope, *, variable_dtype, axis=sentinel, epsilon=1e-5, params=None):
-    if axis is sentinel:
-        axis = x.shape[-1]
-
-    with tf.variable_scope(scope):
-        g = mtf.get_variable(x.mesh, "g", [], initializer=tf.constant_initializer(1),
-                             master_dtype=variable_dtype.master_dtype,
-                             slice_dtype=variable_dtype.slice_dtype,
-                             activation_dtype=variable_dtype.activation_dtype)
-
-        x = norm(x, axis, epsilon)
-        x = x * g
-        return x
-
-
-def layer_norm(x, scope, *, variable_dtype, axis=sentinel, epsilon=1e-5, params=None):
-    """Normalize to mean = 0, std = 1, then do a diagonal affine transform."""
-    if axis is sentinel:
-        axis = x.shape[-1]
-
-    with tf.variable_scope(scope):
-        n_state = x.shape[-1]
-
-        g = mtf.get_variable(x.mesh, "g", [n_state], initializer=tf.constant_initializer(1),
-                             master_dtype=variable_dtype.master_dtype,
-                             slice_dtype=variable_dtype.slice_dtype,
-                             activation_dtype=variable_dtype.activation_dtype)
-        b = mtf.get_variable(x.mesh, "b", [n_state], initializer=tf.constant_initializer(0),
-                             master_dtype=variable_dtype.master_dtype,
-                             slice_dtype=variable_dtype.slice_dtype,
-                             activation_dtype=variable_dtype.activation_dtype)
-
-        x = norm(x, axis, epsilon)
-        x = x * g + b
-        return x
-
-
-def linear_attention(q, k, v):
-    batch_dim, seq_dim, head_dim, dim_out = (v.shape[0], v.shape[1], v.shape[2], v.shape[3])
-    q = mtf.rename_dimension(q, "features_per_head", "features_per_head_in")
-    k = mtf.rename_dimension(k, "features_per_head", "features_per_head_in")
-
-    dim_in = k.shape[-1]
-
-    q = mtf.softmax(q, dim_in)
-    k = mtf.softmax(k, seq_dim)
-
-    context = mtf.einsum([k, v], output_shape=[batch_dim, head_dim, dim_in, dim_out])
-    attn = mtf.einsum([q, context], output_shape=[batch_dim, seq_dim, head_dim, dim_out])
-    return attn
-
-
-def causal_linear_attention(q, k, v, eps = 1e-6):
-    batch_dim, seq_dim, head_dim, dim_out = (v.shape[0], v.shape[1], v.shape[2], v.shape[3])
-    q = mtf.rename_dimension(q, "features_per_head", "features_per_head_in")
-    k = mtf.rename_dimension(k, "features_per_head", "features_per_head_in")
-
-    dim_in = k.shape[-1]
-
-    q = mtf.softmax(q, dim_in)
-    k = mtf.exp(k)
-
-    cumulative_k = mtf.cumsum(k, seq_dim) + eps
-    D_inv = 1. / mtf.einsum([q, cumulative_k], output_shape=[batch_dim, seq_dim, head_dim])
-
-    context = mtf.einsum([k, v], output_shape=[batch_dim, seq_dim, head_dim, dim_in, dim_out])
-    cumulative_context = mtf.cumsum(context, seq_dim)
-
-    attn = mtf.einsum([q, cumulative_context, D_inv], output_shape=[batch_dim, seq_dim, head_dim, dim_out])
-    return attn
-
-
-def linear(x, scope, nf, *, w_init_stdev=0.02, variable_dtype, params=None, scale=False):
-    # nf = number of features
-    if params["scale_by_depth"] and scale:
-        # Scale by sqrt(num_layers), only happens at the final projection before a res block output
-        w_init_stdev = w_init_stdev * (1. / math.sqrt(params["n_layer"]))
-    if params["scale_by_in"]:  # Scale by sqrt(num_input_features)
-        w_init_stdev = w_init_stdev * (1. / math.sqrt(x.shape[-1].size))  # Dimension is a namedtuple of (name, size)
-    # Not in the variable_scope because mtf already has a variable_scope in it
-    with tf.variable_scope("conv1d_main"):
-        c = mtf.layers.dense(x, new_dims=[nf], reduced_dims=[x.shape[-1]], name=scope, use_bias=True,
-                             kernel_initializer=tf.random_normal_initializer(stddev=w_init_stdev),
-                             variable_dtype=variable_dtype,
-                             )
-        return c
-
-
-def memory_key_values(k, v, num_mem_kv, dim_batch, dim_heads, variable_dtype, mesh):
-    """memory / key values from all attention paper"""
-
-    dim_mem_kv = mtf.Dimension("mem_kv_sequence", num_mem_kv)
-    emb_dim = k.shape[-1]
-    mem_std = 1 / math.sqrt(emb_dim.size)
-
-    mem_k = mtf.get_variable(mesh, "mem_k", mtf.Shape([dim_mem_kv, dim_heads, emb_dim]),
-                             initializer=tf.random_normal_initializer(stddev=mem_std),
-                             master_dtype=variable_dtype.master_dtype,
-                             slice_dtype=variable_dtype.slice_dtype,
-                             activation_dtype=variable_dtype.activation_dtype,
-                             )
-    mem_v = mtf.get_variable(mesh, "mem_v", mtf.Shape([dim_mem_kv, dim_heads, emb_dim]),
-                             initializer=tf.random_normal_initializer(stddev=mem_std),
-                             master_dtype=variable_dtype.master_dtype,
-                             slice_dtype=variable_dtype.slice_dtype,
-                             activation_dtype=variable_dtype.activation_dtype)
-
-    mem_k, mem_v = map(lambda t: mtf.broadcast(t, [dim_batch, dim_mem_kv, dim_heads, emb_dim]),
-                       (mem_k, mem_v))
-    mem_k, mem_v = map(lambda t: mtf.rename_dimension(t, "mem_kv_sequence", "sequence"),
-                       (mem_k, mem_v))
-
-    k = mtf.concat([mem_k, k], "sequence")
-    v = mtf.concat([mem_v, v], "sequence")
-    return k, v
-
-
-def attn(x, scope, n_state, *, attention_type, params, bias, dim_seq, memory_length_dim, variable_dtype, context=None, pos_emb=None):
-    # x :: [batch, seq, n_embd]
-    x_shape, dim_batch, *_, dim_embd, mesh = x.shape, *x.shape, x.mesh
-
-    # n_state is the same as config["n_embd"], which is also the same as dim_embd.
-    assert n_state.size % params["n_head"] == 0
-
-    dim_heads = mtf.Dimension("heads", params["n_head"])
-
-    num_mem_kv = params.get("num_mem_kv", 0)
-    use_num_mem_kv = num_mem_kv > 0
-
-    with tf.variable_scope(scope):
-        # Compute attention inputs
-        dim_kv = mtf.Dimension("features_per_head", params["n_embd"] // params["n_head"])
-        mtfparams = mtf.transformer.attention.attention_params_simple(
-            x.mesh,
-            io_dim=dim_embd,
-            kv_dim=dim_kv,
-            heads_dim=dim_heads,
-            variable_dtype=variable_dtype
-        )
-        q = mtfparams.compute_q(x)
-        k = mtfparams.compute_k(x)
-        v = mtfparams.compute_v(x)
-
-        if is_incremental_inference(context):
-            one_hot = mtf.one_hot(context.position - 1, dim_seq, dtype=variable_dtype.master_dtype)
-            inv_one_hot = 1.0 - one_hot
-            old_k, old_v = context.get_states(2)
-            k = old_k * inv_one_hot + k * one_hot
-            v = old_v * inv_one_hot + v * one_hot
-
-        if exists(context):
-            context.record_new_states([k, v])
-
-        if exists(pos_emb):
-            cos, sin = pos_emb
-            k = apply_rotary_emb(k, cos, sin)
-
-            if is_incremental_inference(context):
-                seq_dim = cos.shape.get_dim_by_name('sequence')
-                cos = mtf.gather(cos, context.position - 1, seq_dim)
-                sin = mtf.gather(sin, context.position - 1, seq_dim)
-
-            q = apply_rotary_emb(q, cos, sin)
-
-        with tf.variable_scope("attention"):
-            if attention_type == "local":
-                # `local_attention_1d` has built in autoregressive masking, so we don't need mask_attn_weights.
-                radius = params.get("local_attention_radius", 256)
-
-                if is_incremental_inference(context):
-                    q *= one_hot
-
-                a = mtf_transformer.attention.local_attention_1d(
-                    q, k, v,
-                    length_dim=k.shape[1],
-                    key_dim=dim_kv,
-                    value_dim=dim_kv,
-                    radius=radius,
-                    length_dim_num_splits=1,
-                    fully_autoregressive=params["causal"],
-                    attention_kwargs={},
-                )
-
-                if is_incremental_inference(context):
-                    a = mtf.gather(a, context.position - 1, dim_seq)
-
-            elif attention_type == "global":
-
-                # TODO: pass in fake context
-                # Broadcast mask bias across batch and heads
-                if exists(bias):
-                    if not is_incremental_inference(context):
-                        broadcasted_bias = mtf.broadcast(bias, [dim_batch, dim_heads, bias.shape[-2], bias.shape[-1]])
-                    else:
-                        # In the incremental case, a custom mask needs to be built that masks out all key/values that are greater than the current position
-                        bias = mtf.gather(bias, context.position - 1, dim_seq)
-                        broadcasted_bias = mtf.broadcast(bias, [dim_batch, dim_heads, bias.shape[-1]])
-
-                # memory key / values, from all-attention paper
-                if use_num_mem_kv:
-                    k, v = memory_key_values(k, v, num_mem_kv, dim_batch, dim_heads, variable_dtype, mesh)
-
-                k = mtf.replace_dimensions(k, k.shape[1], memory_length_dim)
-                v = mtf.replace_dimensions(v, v.shape[1], memory_length_dim)
-
-                attn_dropout_rate = params["attn_dropout"] if params["mode"] == "train" else 0
-
-                a = mtf_transformer.attention.attention(
-                    q, k, v,
-                    memory_length_dim=memory_length_dim,
-                    key_dim=dim_kv,
-                    value_dim=dim_kv,
-                    bias=broadcasted_bias,
-                    dropout_rate=attn_dropout_rate
-                )
-
-            elif attention_type == "linear":
-                linear_attn_fn = causal_linear_attention if params["causal"] else linear_attention
-                a = linear_attn_fn(q, k, v)
-
-            else:
-                raise NotImplementedError("Unknown attention type {}!".format(attention_type))
-
-        with tf.variable_scope("compute_output"):
-            a = mtfparams.compute_output(a, x_shape)
-
-        with tf.variable_scope("compute_output_bias"):
-            b = mtf.get_variable(x.mesh, "o_b", [dim_embd], initializer=tf.constant_initializer(0),
-                                 master_dtype=variable_dtype.master_dtype,
-                                 slice_dtype=variable_dtype.slice_dtype,
-                                 activation_dtype=variable_dtype.activation_dtype)
-            a += b
-
-        if params["mode"] == "train" and params["res_dropout"] > 0:
-            a = mtf.dropout(a, rate=params["res_dropout"], name="res_dropout")
-        return a
-
-
-def mlp(x, scope, n_state, *, variable_dtype, params):
-    activation_fn = get_activation_fn(params)
-    with tf.variable_scope(scope):
-        nx = x.shape[-1]
-        h = activation_fn(linear(x, "c_fc", n_state, variable_dtype=variable_dtype, params=params))
-        h2 = linear(h, "c_proj", nx, variable_dtype=variable_dtype, params=params, scale=True)
-        if params["mode"] == "train" and params["res_dropout"] > 0:
-            h2 = mtf.dropout(h2, rate=params["res_dropout"], name="mlp_dropout")
-        return h2
-
-
-def mlp_glu(x, scope, n_state, *, variable_dtype, params):
-    activation_fn = get_activation_fn(params)
-    with tf.variable_scope(scope):
-        nx = x.shape[-1]
-        h = linear(x, "c_fc", n_state, params=params)
-
-        h, gate = mtf.split(h, h.shape[-1], 2)
-        h *= activation_fn(gate)
-
-        h2 = linear(h, "c_proj", nx, variable_dtype=variable_dtype, params=params, scale=True)
-        if params["mode"] == "train" and params["res_dropout"] > 0:
-            h2 = mtf.dropout(h2, rate=params["res_dropout"], name="mlp_dropout")
-        return h2
-
-
-def axial_positional_emb(embd_dim, mesh, params, variable_dtype):
-    # Use axial position encoding
-    axial_dim_1, axial_dim_2 = params["axial_pos_emb"]
-
-    axial_dim = mtf.Dimension("axial_dim", axial_dim_1 * axial_dim_2)
-    dim_axials = [mtf.Dimension(f"axial_dim_{i}", t) for i, t in enumerate((axial_dim_1, axial_dim_2))]
-
-    axial_wpe_1 = mtf.get_variable(mesh, "axial_wpe_1", mtf.Shape([dim_axials[0], embd_dim]),
-                                   initializer=tf.random_normal_initializer(stddev=0.01),
-                                   master_dtype=variable_dtype.master_dtype,
-                                   slice_dtype=variable_dtype.slice_dtype,
-                                   activation_dtype=variable_dtype.activation_dtype)
-
-    axial_wpe_2 = mtf.get_variable(mesh, "axial_wpe_2", mtf.Shape([dim_axials[1], embd_dim]),
-                                   initializer=tf.random_normal_initializer(stddev=0.01),
-                                   master_dtype=variable_dtype.master_dtype,
-                                   slice_dtype=variable_dtype.slice_dtype,
-                                   activation_dtype=variable_dtype.activation_dtype)
-
-    axial_wpe_1, axial_wpe_2 = map(lambda t: mtf.broadcast(t, [dim_axials[0], dim_axials[1], embd_dim]),
-                                   (axial_wpe_1, axial_wpe_2))
-    wpe = (axial_wpe_1 + axial_wpe_2) / 2
-
-    wpe = mtf.reshape(wpe, [axial_dim, embd_dim])
-
-    return wpe
-
-def rotary_positional_emb(mesh, sequence_dim, params, variable_dtype):
-    dtype = variable_dtype.master_dtype
-    dim_head = params["n_embd"] // params["n_head"]
-
-    dim_head = mtf.Dimension("features_per_head", dim_head)
-    half_dim_head = mtf.Dimension("half_features_per_head", dim_head.size // 2)
-
-    dim_range = mtf.range(mesh, half_dim_head, dtype) * 2 / dim_head.size
-    half_freqs = 1. / mtf.pow(mtf.constant(mesh, 10000, dtype = dtype), dim_range)
-
-    seq = mtf.range(mesh, sequence_dim, dtype)
-    half_freqs = mtf.einsum([half_freqs, seq], [sequence_dim, half_dim_head])
-
-    freqs = mtf.concat((half_freqs, half_freqs), half_dim_head.name)
-    freqs = mtf.rename_dimension(freqs, half_dim_head.name, dim_head.name)
-    return mtf.cos(freqs), mtf.sin(freqs)
-
-def rotate_half(x):
-    dim_head_name = "features_per_head"
-    dim_head = x.shape.get_dim_by_name(dim_head_name)
-    half_dim_head_size = dim_head.size // 2
-    x1 = mtf.slice(x, 0, half_dim_head_size, dim_head_name)
-    x2 = mtf.slice(x, half_dim_head_size, half_dim_head_size, dim_head_name)
-    return mtf.concat((-x2, x1), dim_head.name)
-
-def apply_rotary_emb(x, cos, sin):
-    rotated_x = rotate_half(x)
-    return x * cos + rotated_x * sin
diff --git a/spaces/guetLzy/Real-ESRGAN-Demo/docs/model_zoo.md b/spaces/guetLzy/Real-ESRGAN-Demo/docs/model_zoo.md
deleted file mode 100644
index 132cc514bac6b447addac8485e0622a834d34474..0000000000000000000000000000000000000000
--- a/spaces/guetLzy/Real-ESRGAN-Demo/docs/model_zoo.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# :european_castle: Model Zoo
-
-- [For General Images](#for-general-images)
-- [For Anime Images](#for-anime-images)
-- [For Anime Videos](#for-anime-videos)
-
----
-
-## For General Images
-
-| Models                                                                                                                          | Scale | Description                                  |
-| ------------------------------------------------------------------------------------------------------------------------------- | :---- | :------------------------------------------- |
-| [RealESRGAN_x4plus](https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth)                      | X4    | X4 model for general images                  |
-| [RealESRGAN_x2plus](https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth)                      | X2    | X2 model for general images                  |
-| [RealESRNet_x4plus](https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.1/RealESRNet_x4plus.pth)                      | X4    | X4 model with MSE loss (over-smooth effects) |
-| [official ESRGAN_x4](https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.1/ESRGAN_SRx4_DF2KOST_official-ff704c30.pth) | X4    | official ESRGAN model                        |
-| [realesr-general-x4v3](https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-x4v3.pth) | X4 (can also be used for X1, X2, X3) | A tiny small model (consume much fewer GPU memory and time); not too strong deblur and denoise capacity |
-
-The following models are **discriminators**, which are usually used for fine-tuning.
-
-| Models                                                                                                                 | Corresponding model |
-| ---------------------------------------------------------------------------------------------------------------------- | :------------------ |
-| [RealESRGAN_x4plus_netD](https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.3/RealESRGAN_x4plus_netD.pth) | RealESRGAN_x4plus   |
-| [RealESRGAN_x2plus_netD](https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.3/RealESRGAN_x2plus_netD.pth) | RealESRGAN_x2plus   |
-
-## For Anime Images / Illustrations
-
-| Models                                                                                                                         | Scale | Description                                                 |
-| ------------------------------------------------------------------------------------------------------------------------------ | :---- | :---------------------------------------------------------- |
-| [RealESRGAN_x4plus_anime_6B](https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth) | X4    | Optimized for anime images; 6 RRDB blocks (smaller network) |
-
-The following models are **discriminators**, which are usually used for fine-tuning.
-
-| Models                                                                                                                                   | Corresponding model        |
-| ---------------------------------------------------------------------------------------------------------------------------------------- | :------------------------- |
-| [RealESRGAN_x4plus_anime_6B_netD](https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B_netD.pth) | RealESRGAN_x4plus_anime_6B |
-
-## For Animation Videos
-
-| Models                                                                                                                             | Scale | Description                    |
-| ---------------------------------------------------------------------------------------------------------------------------------- | :---- | :----------------------------- |
-| [realesr-animevideov3](https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-animevideov3.pth) | X4<sup>1</sup>    | Anime video model with XS size |
-
-Note: <br>
-<sup>1</sup> This model can also be used for X1, X2, X3.
-
-The following models are **discriminators**, which are usually used for fine-tuning.
-
-TODO
diff --git a/spaces/gwang-kim/DATID-3D/eg3d/torch_utils/ops/filtered_lrelu.cpp b/spaces/gwang-kim/DATID-3D/eg3d/torch_utils/ops/filtered_lrelu.cpp
deleted file mode 100644
index 4f55466235a020b0f5e150350bfdcd8b2a1e579d..0000000000000000000000000000000000000000
--- a/spaces/gwang-kim/DATID-3D/eg3d/torch_utils/ops/filtered_lrelu.cpp
+++ /dev/null
@@ -1,304 +0,0 @@
-/*
- * SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
- * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
- *
- * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
- * property and proprietary rights in and to this material, related
- * documentation and any modifications thereto. Any use, reproduction,
- * disclosure or distribution of this material and related documentation
- * without an express license agreement from NVIDIA CORPORATION or
- * its affiliates is strictly prohibited.
- */
-
-#include <torch/extension.h>
-#include <ATen/cuda/CUDAContext.h>
-#include <c10/cuda/CUDAGuard.h>
-#include "filtered_lrelu.h"
-
-//------------------------------------------------------------------------
-
-static std::tuple<torch::Tensor, torch::Tensor, int> filtered_lrelu(
-    torch::Tensor x, torch::Tensor fu, torch::Tensor fd, torch::Tensor b, torch::Tensor si,
-    int up, int down, int px0, int px1, int py0, int py1, int sx, int sy, float gain, float slope, float clamp, bool flip_filters, bool writeSigns)
-{
-    // Set CUDA device.
-    TORCH_CHECK(x.is_cuda(), "x must reside on CUDA device");
-    const at::cuda::OptionalCUDAGuard device_guard(device_of(x));
-
-    // Validate arguments.
-    TORCH_CHECK(fu.device() == x.device() && fd.device() == x.device() && b.device() == x.device(), "all input tensors must reside on the same device");
-    TORCH_CHECK(fu.dtype() == torch::kFloat && fd.dtype() == torch::kFloat, "fu and fd must be float32");
-    TORCH_CHECK(b.dtype() == x.dtype(), "x and b must have the same dtype");
-    TORCH_CHECK(x.dtype() == torch::kHalf || x.dtype() == torch::kFloat, "x and b must be float16 or float32");
-    TORCH_CHECK(x.dim() == 4, "x must be rank 4");
-    TORCH_CHECK(x.size(0) * x.size(1) <= INT_MAX && x.size(2) <= INT_MAX && x.size(3) <= INT_MAX, "x is too large");
-    TORCH_CHECK(x.numel() > 0, "x is empty");
-    TORCH_CHECK((fu.dim() == 1 || fu.dim() == 2) && (fd.dim() == 1 || fd.dim() == 2), "fu and fd must be rank 1 or 2");
-    TORCH_CHECK(fu.size(0) <= INT_MAX && fu.size(-1) <= INT_MAX, "fu is too large");
-    TORCH_CHECK(fd.size(0) <= INT_MAX && fd.size(-1) <= INT_MAX, "fd is too large");
-    TORCH_CHECK(fu.numel() > 0, "fu is empty");
-    TORCH_CHECK(fd.numel() > 0, "fd is empty");
-    TORCH_CHECK(b.dim() == 1 && b.size(0) == x.size(1), "b must be a vector with the same number of channels as x");
-    TORCH_CHECK(up >= 1 && down >= 1, "up and down must be at least 1");
-
-    // Figure out how much shared memory is available on the device.
-    int maxSharedBytes = 0;
-    AT_CUDA_CHECK(cudaDeviceGetAttribute(&maxSharedBytes, cudaDevAttrMaxSharedMemoryPerBlockOptin, x.device().index()));
-    int sharedKB = maxSharedBytes >> 10;
-
-    // Populate enough launch parameters to check if a CUDA kernel exists.
-    filtered_lrelu_kernel_params p;
-    p.up      = up;
-    p.down    = down;
-    p.fuShape = make_int2((int)fu.size(-1), fu.dim() == 2 ? (int)fu.size(0) : 0); // shape [n, 0] indicates separable filter.
-    p.fdShape = make_int2((int)fd.size(-1), fd.dim() == 2 ? (int)fd.size(0) : 0);
-    filtered_lrelu_kernel_spec test_spec = choose_filtered_lrelu_kernel<float, int32_t, false, false>(p, sharedKB);
-    if (!test_spec.exec)
-    {
-        // No kernel found - return empty tensors and indicate missing kernel with return code of -1.
-        return std::make_tuple(torch::Tensor(), torch::Tensor(), -1);
-    }
-
-    // Input/output element size.
-    int64_t sz = (x.dtype() == torch::kHalf) ? 2 : 4;
-
-    // Input sizes.
-    int64_t xw = (int)x.size(3);
-    int64_t xh = (int)x.size(2);
-    int64_t fut_w = (int)fu.size(-1) - 1;
-    int64_t fut_h = (int)fu.size(0)  - 1;
-    int64_t fdt_w = (int)fd.size(-1) - 1;
-    int64_t fdt_h = (int)fd.size(0)  - 1;
-
-    // Logical size of upsampled buffer.
-    int64_t cw = xw * up + (px0 + px1) - fut_w;
-    int64_t ch = xh * up + (py0 + py1) - fut_h;
-    TORCH_CHECK(cw > fdt_w && ch > fdt_h, "upsampled buffer must be at least the size of downsampling filter");
-    TORCH_CHECK(cw <= INT_MAX && ch <= INT_MAX, "upsampled buffer is too large");
-
-    // Compute output size and allocate.
-    int64_t yw = (cw - fdt_w + (down - 1)) / down;
-    int64_t yh = (ch - fdt_h + (down - 1)) / down;
-    TORCH_CHECK(yw > 0 && yh > 0, "output must be at least 1x1");
-    TORCH_CHECK(yw <= INT_MAX && yh <= INT_MAX, "output is too large");
-    torch::Tensor y = torch::empty({x.size(0), x.size(1), yh, yw}, x.options(), x.suggest_memory_format());
-
-    // Allocate sign tensor.
-    torch::Tensor so;
-    torch::Tensor s = si;
-    bool readSigns = !!s.numel();
-    int64_t sw_active = 0; // Active width of sign tensor.
-    if (writeSigns)
-    {
-        sw_active = yw * down - (down - 1) + fdt_w;     // Active width in elements.
-        int64_t sh = yh * down - (down - 1) + fdt_h;    // Height = active height.
-        int64_t sw = (sw_active + 15) & ~15;            // Width  = active width in elements, rounded up to multiple of 16.
-        TORCH_CHECK(sh <= INT_MAX && (sw >> 2) <= INT_MAX, "signs is too large");
-        s = so = torch::empty({x.size(0), x.size(1), sh, sw >> 2}, x.options().dtype(torch::kUInt8), at::MemoryFormat::Contiguous);
-    }
-    else if (readSigns)
-        sw_active = s.size(3) << 2;
-
-    // Validate sign tensor if in use.
-    if (readSigns || writeSigns)
-    {
-        TORCH_CHECK(s.is_contiguous(), "signs must be contiguous");
-        TORCH_CHECK(s.dtype() == torch::kUInt8, "signs must be uint8");
-        TORCH_CHECK(s.device() == x.device(), "signs must reside on the same device as x");
-        TORCH_CHECK(s.dim() == 4, "signs must be rank 4");
-        TORCH_CHECK(s.size(0) == x.size(0) && s.size(1) == x.size(1), "signs must have same batch & channels as x");
-        TORCH_CHECK(s.size(2) <= INT_MAX && s.size(3) <= INT_MAX, "signs is too large");
-    }
-
-    // Populate rest of CUDA kernel parameters.
-    p.x         = x.data_ptr();
-    p.y         = y.data_ptr();
-    p.b         = b.data_ptr();
-    p.s         = (readSigns || writeSigns) ? s.data_ptr<unsigned char>() : 0;
-    p.fu        = fu.data_ptr<float>();
-    p.fd        = fd.data_ptr<float>();
-    p.pad0      = make_int2(px0, py0);
-    p.gain      = gain;
-    p.slope     = slope;
-    p.clamp     = clamp;
-    p.flip      = (flip_filters) ? 1 : 0;
-    p.xShape    = make_int4((int)x.size(3), (int)x.size(2), (int)x.size(1), (int)x.size(0));
-    p.yShape    = make_int4((int)y.size(3), (int)y.size(2), (int)y.size(1), (int)y.size(0));
-    p.sShape    = (readSigns || writeSigns) ? make_int2((int)s.size(3), (int)s.size(2)) : make_int2(0, 0); // Width is in bytes. Contiguous.
-    p.sOfs      = make_int2(sx, sy);
-    p.swLimit   = (sw_active + 3) >> 2; // Rounded up to bytes.
-
-    // x, y, b strides are in bytes.
-    p.xStride   = make_longlong4(sz * x.stride(3), sz * x.stride(2), sz * x.stride(1), sz * x.stride(0));
-    p.yStride   = make_longlong4(sz * y.stride(3), sz * y.stride(2), sz * y.stride(1), sz * y.stride(0));
-    p.bStride   = sz * b.stride(0);
-
-    // fu, fd strides are in elements.
-    p.fuStride  = make_longlong3(fu.stride(-1), fu.dim() == 2 ? fu.stride(0) : 0, 0);
-    p.fdStride  = make_longlong3(fd.stride(-1), fd.dim() == 2 ? fd.stride(0) : 0, 0);
-
-    // Determine if indices don't fit in int32. Support negative strides although Torch currently never produces those.
-    bool index64b = false;
-    if (std::abs(p.bStride * x.size(1)) > INT_MAX) index64b = true;
-    if (std::min(x.size(0) * p.xStride.w, 0ll) + std::min(x.size(1) * p.xStride.z, 0ll) + std::min(x.size(2) * p.xStride.y, 0ll) + std::min(x.size(3) * p.xStride.x, 0ll) < -INT_MAX) index64b = true;
-    if (std::max(x.size(0) * p.xStride.w, 0ll) + std::max(x.size(1) * p.xStride.z, 0ll) + std::max(x.size(2) * p.xStride.y, 0ll) + std::max(x.size(3) * p.xStride.x, 0ll) >  INT_MAX) index64b = true;
-    if (std::min(y.size(0) * p.yStride.w, 0ll) + std::min(y.size(1) * p.yStride.z, 0ll) + std::min(y.size(2) * p.yStride.y, 0ll) + std::min(y.size(3) * p.yStride.x, 0ll) < -INT_MAX) index64b = true;
-    if (std::max(y.size(0) * p.yStride.w, 0ll) + std::max(y.size(1) * p.yStride.z, 0ll) + std::max(y.size(2) * p.yStride.y, 0ll) + std::max(y.size(3) * p.yStride.x, 0ll) >  INT_MAX) index64b = true;
-    if (s.numel() > INT_MAX) index64b = true;
-
-    // Choose CUDA kernel.
-    filtered_lrelu_kernel_spec spec = { 0 };
-    AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "filtered_lrelu_cuda", [&]
-    {
-        if constexpr (sizeof(scalar_t) <= 4) // Exclude doubles. constexpr prevents template instantiation.
-        {
-            // Choose kernel based on index type, datatype and sign read/write modes.
-            if      (!index64b &&  writeSigns && !readSigns) spec = choose_filtered_lrelu_kernel<scalar_t, int32_t, true,  false>(p, sharedKB);
-            else if (!index64b && !writeSigns &&  readSigns) spec = choose_filtered_lrelu_kernel<scalar_t, int32_t, false, true >(p, sharedKB);
-            else if (!index64b && !writeSigns && !readSigns) spec = choose_filtered_lrelu_kernel<scalar_t, int32_t, false, false>(p, sharedKB);
-            else if ( index64b &&  writeSigns && !readSigns) spec = choose_filtered_lrelu_kernel<scalar_t, int64_t, true,  false>(p, sharedKB);
-            else if ( index64b && !writeSigns &&  readSigns) spec = choose_filtered_lrelu_kernel<scalar_t, int64_t, false, true >(p, sharedKB);
-            else if ( index64b && !writeSigns && !readSigns) spec = choose_filtered_lrelu_kernel<scalar_t, int64_t, false, false>(p, sharedKB);
-        }
-    });
-    TORCH_CHECK(spec.exec, "internal error - CUDA kernel not found") // This should not happen because we tested earlier that kernel exists.
-
-    // Launch CUDA kernel.
-    void* args[] = {&p};
-    int bx = spec.numWarps * 32;
-    int gx = (p.yShape.x - 1) / spec.tileOut.x + 1;
-    int gy = (p.yShape.y - 1) / spec.tileOut.y + 1;
-    int gz = p.yShape.z * p.yShape.w;
-
-    // Repeat multiple horizontal tiles in a CTA?
-    if (spec.xrep)
-    {
-        p.tilesXrep = spec.xrep;
-        p.tilesXdim = gx;
-
-        gx = (gx + p.tilesXrep - 1) / p.tilesXrep;
-        std::swap(gx, gy);
-    }
-    else
-    {
-        p.tilesXrep = 0;
-        p.tilesXdim = 0;
-    }
-
-    // Launch filter setup kernel.
-    AT_CUDA_CHECK(cudaLaunchKernel(spec.setup, 1, 1024, args, 0, at::cuda::getCurrentCUDAStream()));
-
-    // Copy kernels to constant memory.
-    if      ( writeSigns && !readSigns) AT_CUDA_CHECK((copy_filters<true,  false>(at::cuda::getCurrentCUDAStream())));
-    else if (!writeSigns &&  readSigns) AT_CUDA_CHECK((copy_filters<false, true >(at::cuda::getCurrentCUDAStream())));
-    else if (!writeSigns && !readSigns) AT_CUDA_CHECK((copy_filters<false, false>(at::cuda::getCurrentCUDAStream())));
-
-    // Set cache and shared memory configurations for main kernel.
-    AT_CUDA_CHECK(cudaFuncSetCacheConfig(spec.exec, cudaFuncCachePreferShared));
-    if (spec.dynamicSharedKB) // Need dynamically allocated shared memory?
-        AT_CUDA_CHECK(cudaFuncSetAttribute(spec.exec, cudaFuncAttributeMaxDynamicSharedMemorySize, spec.dynamicSharedKB << 10));
-    AT_CUDA_CHECK(cudaFuncSetSharedMemConfig(spec.exec, cudaSharedMemBankSizeFourByte));
-
-    // Launch main kernel.
-    const int maxSubGz = 65535; // CUDA maximum for block z dimension.
-    for (int zofs=0; zofs < gz; zofs += maxSubGz) // Do multiple launches if gz is too big.
-    {
-        p.blockZofs = zofs;
-        int subGz = std::min(maxSubGz, gz - zofs);
-        AT_CUDA_CHECK(cudaLaunchKernel(spec.exec, dim3(gx, gy, subGz), bx, args, spec.dynamicSharedKB << 10, at::cuda::getCurrentCUDAStream()));
-    }
-
-    // Done.
-    return std::make_tuple(y, so, 0);
-}
-
-//------------------------------------------------------------------------
-
-static torch::Tensor filtered_lrelu_act(torch::Tensor x, torch::Tensor si, int sx, int sy, float gain, float slope, float clamp, bool writeSigns)
-{
-    // Set CUDA device.
-    TORCH_CHECK(x.is_cuda(), "x must reside on CUDA device");
-    const at::cuda::OptionalCUDAGuard device_guard(device_of(x));
-
-    // Validate arguments.
-    TORCH_CHECK(x.dim() == 4, "x must be rank 4");
-    TORCH_CHECK(x.size(0) * x.size(1) <= INT_MAX && x.size(2) <= INT_MAX && x.size(3) <= INT_MAX, "x is too large");
-    TORCH_CHECK(x.numel() > 0, "x is empty");
-    TORCH_CHECK(x.dtype() == torch::kHalf || x.dtype() == torch::kFloat || x.dtype() == torch::kDouble, "x must be float16, float32 or float64");
-
-    // Output signs if we don't have sign input.
-    torch::Tensor so;
-    torch::Tensor s = si;
-    bool readSigns = !!s.numel();
-    if (writeSigns)
-    {
-        int64_t sw = x.size(3);
-        sw = (sw + 15) & ~15; // Round to a multiple of 16 for coalescing.
-        s = so = torch::empty({x.size(0), x.size(1), x.size(2), sw >> 2}, x.options().dtype(torch::kUInt8), at::MemoryFormat::Contiguous);
-    }
-
-    // Validate sign tensor if in use.
-    if (readSigns || writeSigns)
-    {
-        TORCH_CHECK(s.is_contiguous(), "signs must be contiguous");
-        TORCH_CHECK(s.dtype() == torch::kUInt8, "signs must be uint8");
-        TORCH_CHECK(s.device() == x.device(), "signs must reside on the same device as x");
-        TORCH_CHECK(s.dim() == 4, "signs must be rank 4");
-        TORCH_CHECK(s.size(0) == x.size(0) && s.size(1) == x.size(1), "signs must have same batch & channels as x");
-        TORCH_CHECK(s.size(2) <= INT_MAX && (s.size(3) << 2) <= INT_MAX, "signs tensor is too large");
-    }
-
-    // Initialize CUDA kernel parameters.
-    filtered_lrelu_act_kernel_params p;
-    p.x         = x.data_ptr();
-    p.s         = (readSigns || writeSigns) ? s.data_ptr<unsigned char>() : 0;
-    p.gain      = gain;
-    p.slope     = slope;
-    p.clamp     = clamp;
-    p.xShape    = make_int4((int)x.size(3), (int)x.size(2), (int)x.size(1), (int)x.size(0));
-    p.xStride   = make_longlong4(x.stride(3), x.stride(2), x.stride(1), x.stride(0));
-    p.sShape    = (readSigns || writeSigns) ? make_int2((int)s.size(3) << 2, (int)s.size(2)) : make_int2(0, 0); // Width is in elements. Contiguous.
-    p.sOfs      = make_int2(sx, sy);
-
-    // Choose CUDA kernel.
-    void* func = 0;
-    AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "filtered_lrelu_act_cuda", [&]
-    {
-        if (writeSigns)
-            func = choose_filtered_lrelu_act_kernel<scalar_t, true, false>();
-        else if (readSigns)
-            func = choose_filtered_lrelu_act_kernel<scalar_t, false, true>();
-        else
-            func = choose_filtered_lrelu_act_kernel<scalar_t, false, false>();
-    });
-    TORCH_CHECK(func, "internal error - CUDA kernel not found");
-
-    // Launch CUDA kernel.
-    void* args[] = {&p};
-    int bx = 128; // 4 warps per block.
-
-    // Logical size of launch = writeSigns ? p.s : p.x
-    uint32_t gx = writeSigns ? p.sShape.x : p.xShape.x;
-    uint32_t gy = writeSigns ? p.sShape.y : p.xShape.y;
-    uint32_t gz = p.xShape.z * p.xShape.w; // Same as in p.sShape if signs are in use.
-    gx = (gx - 1) / bx + 1;
-
-    // Make sure grid y and z dimensions are within CUDA launch limits. Kernel loops internally to do the rest.
-    const uint32_t gmax = 65535;
-    gy = std::min(gy, gmax);
-    gz = std::min(gz, gmax);
-
-    // Launch.
-    AT_CUDA_CHECK(cudaLaunchKernel(func, dim3(gx, gy, gz), bx, args, 0, at::cuda::getCurrentCUDAStream()));
-    return so;
-}
-
-//------------------------------------------------------------------------
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m)
-{
-    m.def("filtered_lrelu",      &filtered_lrelu);      // The whole thing.
-    m.def("filtered_lrelu_act_", &filtered_lrelu_act);  // Activation and sign tensor handling only. Modifies data tensor in-place.
-}
-
-//------------------------------------------------------------------------
diff --git a/spaces/haakohu/deep_privacy2/dp2/anonymizer/histogram_match_anonymizers.py b/spaces/haakohu/deep_privacy2/dp2/anonymizer/histogram_match_anonymizers.py
deleted file mode 100644
index 421c80d5624b113afdf9aa4908b5c9cd0ba33c94..0000000000000000000000000000000000000000
--- a/spaces/haakohu/deep_privacy2/dp2/anonymizer/histogram_match_anonymizers.py
+++ /dev/null
@@ -1,93 +0,0 @@
-
-import torch
-import tops
-import numpy as np
-from kornia.color import rgb_to_hsv
-from dp2 import utils
-from kornia.enhance import histogram
-from .anonymizer import Anonymizer
-import torchvision.transforms.functional as F
-from skimage.exposure import match_histograms
-from kornia.filters import gaussian_blur2d
-
-
-class LatentHistogramMatchAnonymizer(Anonymizer):
-
-    def forward_G(
-        self,
-        G,
-        batch,
-        multi_modal_truncation: bool,
-        amp: bool,
-        z_idx: int,
-        truncation_value: float,
-        idx: int,
-        n_sampling_steps: int = 1,
-        all_styles=None,
-    ):
-        batch["img"] = F.normalize(batch["img"].float(), [0.5*255, 0.5*255, 0.5*255], [0.5*255, 0.5*255, 0.5*255])
-        batch["img"] = batch["img"].float()
-        batch["condition"] = batch["mask"].float() * batch["img"]
-
-        assert z_idx is None and all_styles is None, "Arguments not supported with n_sampling_steps > 1."
-        real_hls = rgb_to_hsv(utils.denormalize_img(batch["img"]))
-        real_hls[:, 0] /= 2 * torch.pi
-        indices = [1, 2]
-        hist_kwargs = dict(
-            bins=torch.linspace(0, 1, 256, dtype=torch.float32, device=tops.get_device()),
-            bandwidth=torch.tensor(1., device=tops.get_device()))
-        real_hist = [histogram(real_hls[:, i].flatten(start_dim=1), **hist_kwargs) for i in indices]
-        for j in range(n_sampling_steps):
-            if j == 0:
-                if multi_modal_truncation:
-                    w = G.style_net.multi_modal_truncate(
-                        truncation_value=truncation_value, **batch, w_indices=None).detach()
-                else:
-                    w = G.style_net.get_truncated(truncation_value, **batch).detach()
-                assert z_idx is None and all_styles is None, "Arguments not supported with n_sampling_steps > 1."
-                w.requires_grad = True
-                optim = torch.optim.Adam([w])
-            with torch.set_grad_enabled(True):
-                with torch.cuda.amp.autocast(amp):
-                    anonymized_im = G(**batch, truncation_value=None, w=w)["img"]
-                fake_hls = rgb_to_hsv(anonymized_im*0.5 + 0.5)
-                fake_hls[:, 0] /= 2 * torch.pi
-                fake_hist = [histogram(fake_hls[:, i].flatten(start_dim=1), **hist_kwargs) for i in indices]
-                dist = sum([utils.torch_wasserstein_loss(r, f) for r, f in zip(real_hist, fake_hist)])
-                dist.backward()
-                if w.grad.sum() == 0:
-                    break
-                assert w.grad.sum() != 0
-                optim.step()
-                optim.zero_grad()
-                if dist < 0.02:
-                    break
-        anonymized_im = (anonymized_im+1).div(2).clamp(0, 1).mul(255)
-        return anonymized_im
-
-
-class HistogramMatchAnonymizer(Anonymizer):
-
-    def forward_G(self, batch, *args, **kwargs):
-        rimg = batch["img"]
-        batch["img"] = F.normalize(batch["img"].float(), [0.5*255, 0.5*255, 0.5*255], [0.5*255, 0.5*255, 0.5*255])
-        batch["img"] = batch["img"].float()
-        batch["condition"] = batch["mask"].float() * batch["img"]
-
-        anonymized_im = super().forward_G(batch, *args, **kwargs)
-
-        equalized_gim = match_histograms(tops.im2numpy(anonymized_im.round().clamp(0, 255).byte()), tops.im2numpy(rimg))
-        if equalized_gim.dtype != np.uint8:
-            equalized_gim = equalized_gim.astype(np.float32)
-            assert equalized_gim.dtype == np.float32, equalized_gim.dtype
-            equalized_gim = tops.im2torch(equalized_gim, to_float=False)[0]
-        else:
-            equalized_gim = tops.im2torch(equalized_gim, to_float=False).float()[0]
-        equalized_gim = equalized_gim.to(device=rimg.device)
-        assert equalized_gim.dtype == torch.float32
-        gaussian_mask = 1 - (batch["maskrcnn_mask"][0].repeat(3, 1, 1) > 0.5).float()
-
-        gaussian_mask = gaussian_blur2d(gaussian_mask[None], kernel_size=[19, 19], sigma=[10, 10])[0]
-        gaussian_mask = gaussian_mask / gaussian_mask.max()
-        anonymized_im = gaussian_mask * equalized_gim + (1-gaussian_mask) * anonymized_im
-        return anonymized_im
diff --git a/spaces/hareshgautham/Myspace/README.md b/spaces/hareshgautham/Myspace/README.md
deleted file mode 100644
index c9da4cd559a54423c30cd6be0d6b40080e4096c8..0000000000000000000000000000000000000000
--- a/spaces/hareshgautham/Myspace/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: AutoTrain Advanced
-emoji: 🚀
-colorFrom: blue
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/hca97/Mosquito-Detection/my_models/torch_hub_cache/yolov5/utils/loggers/comet/README.md b/spaces/hca97/Mosquito-Detection/my_models/torch_hub_cache/yolov5/utils/loggers/comet/README.md
deleted file mode 100644
index 3ad52b01b4e9374e1ff7e93cc6d2f2dea061cb94..0000000000000000000000000000000000000000
--- a/spaces/hca97/Mosquito-Detection/my_models/torch_hub_cache/yolov5/utils/loggers/comet/README.md
+++ /dev/null
@@ -1,258 +0,0 @@
-<img src="https://cdn.comet.ml/img/notebook_logo.png">
-
-# YOLOv5 with Comet
-
-This guide will cover how to use YOLOv5 with [Comet](https://bit.ly/yolov5-readme-comet2)
-
-# About Comet
-
-Comet builds tools that help data scientists, engineers, and team leaders accelerate and optimize machine learning and deep learning models.
-
-Track and visualize model metrics in real time, save your hyperparameters, datasets, and model checkpoints, and visualize your model predictions with [Comet Custom Panels](https://www.comet.com/docs/v2/guides/comet-dashboard/code-panels/about-panels/?utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)!
-Comet makes sure you never lose track of your work and makes it easy to share results and collaborate across teams of all sizes!
-
-# Getting Started
-
-## Install Comet
-
-```shell
-pip install comet_ml
-```
-
-## Configure Comet Credentials
-
-There are two ways to configure Comet with YOLOv5.
-
-You can either set your credentials through environment variables
-
-**Environment Variables**
-
-```shell
-export COMET_API_KEY=<Your Comet API Key>
-export COMET_PROJECT_NAME=<Your Comet Project Name> # This will default to 'yolov5'
-```
-
-Or create a `.comet.config` file in your working directory and set your credentials there.
-
-**Comet Configuration File**
-
-```
-[comet]
-api_key=<Your Comet API Key>
-project_name=<Your Comet Project Name> # This will default to 'yolov5'
-```
-
-## Run the Training Script
-
-```shell
-# Train YOLOv5s on COCO128 for 5 epochs
-python train.py --img 640 --batch 16 --epochs 5 --data coco128.yaml --weights yolov5s.pt
-```
-
-That's it! Comet will automatically log your hyperparameters, command line arguments, training and validation metrics. You can visualize and analyze your runs in the Comet UI
-
-<img width="1920" alt="yolo-ui" src="https://user-images.githubusercontent.com/26833433/202851203-164e94e1-2238-46dd-91f8-de020e9d6b41.png">
-
-# Try out an Example!
-
-Check out an example of a [completed run here](https://www.comet.com/examples/comet-example-yolov5/a0e29e0e9b984e4a822db2a62d0cb357?experiment-tab=chart&showOutliers=true&smoothing=0&transformY=smoothing&xAxis=step&utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)
-
-Or better yet, try it out yourself in this Colab Notebook
-
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/comet-ml/comet-examples/blob/master/integrations/model-training/yolov5/notebooks/Comet_and_YOLOv5.ipynb)
-
-# Log automatically
-
-By default, Comet will log the following items
-
-## Metrics
-
-- Box Loss, Object Loss, Classification Loss for the training and validation data
-- mAP_0.5, mAP_0.5:0.95 metrics for the validation data.
-- Precision and Recall for the validation data
-
-## Parameters
-
-- Model Hyperparameters
-- All parameters passed through the command line options
-
-## Visualizations
-
-- Confusion Matrix of the model predictions on the validation data
-- Plots for the PR and F1 curves across all classes
-- Correlogram of the Class Labels
-
-# Configure Comet Logging
-
-Comet can be configured to log additional data either through command line flags passed to the training script
-or through environment variables.
-
-```shell
-export COMET_MODE=online # Set whether to run Comet in 'online' or 'offline' mode. Defaults to online
-export COMET_MODEL_NAME=<your model name> #Set the name for the saved model. Defaults to yolov5
-export COMET_LOG_CONFUSION_MATRIX=false # Set to disable logging a Comet Confusion Matrix. Defaults to true
-export COMET_MAX_IMAGE_UPLOADS=<number of allowed images to upload to Comet> # Controls how many total image predictions to log to Comet. Defaults to 100.
-export COMET_LOG_PER_CLASS_METRICS=true # Set to log evaluation metrics for each detected class at the end of training. Defaults to false
-export COMET_DEFAULT_CHECKPOINT_FILENAME=<your checkpoint filename> # Set this if you would like to resume training from a different checkpoint. Defaults to 'last.pt'
-export COMET_LOG_BATCH_LEVEL_METRICS=true # Set this if you would like to log training metrics at the batch level. Defaults to false.
-export COMET_LOG_PREDICTIONS=true # Set this to false to disable logging model predictions
-```
-
-## Logging Checkpoints with Comet
-
-Logging Models to Comet is disabled by default. To enable it, pass the `save-period` argument to the training script. This will save the
-logged checkpoints to Comet based on the interval value provided by `save-period`
-
-```shell
-python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data coco128.yaml \
---weights yolov5s.pt \
---save-period 1
-```
-
-## Logging Model Predictions
-
-By default, model predictions (images, ground truth labels and bounding boxes) will be logged to Comet.
-
-You can control the frequency of logged predictions and the associated images by passing the `bbox_interval` command line argument. Predictions can be visualized using Comet's Object Detection Custom Panel. This frequency corresponds to every Nth batch of data per epoch. In the example below, we are logging every 2nd batch of data for each epoch.
-
-**Note:** The YOLOv5 validation dataloader will default to a batch size of 32, so you will have to set the logging frequency accordingly.
-
-Here is an [example project using the Panel](https://www.comet.com/examples/comet-example-yolov5?shareable=YcwMiJaZSXfcEXpGOHDD12vA1&utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)
-
-```shell
-python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data coco128.yaml \
---weights yolov5s.pt \
---bbox_interval 2
-```
-
-### Controlling the number of Prediction Images logged to Comet
-
-When logging predictions from YOLOv5, Comet will log the images associated with each set of predictions. By default a maximum of 100 validation images are logged. You can increase or decrease this number using the `COMET_MAX_IMAGE_UPLOADS` environment variable.
-
-```shell
-env COMET_MAX_IMAGE_UPLOADS=200 python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data coco128.yaml \
---weights yolov5s.pt \
---bbox_interval 1
-```
-
-### Logging Class Level Metrics
-
-Use the `COMET_LOG_PER_CLASS_METRICS` environment variable to log mAP, precision, recall, f1 for each class.
-
-```shell
-env COMET_LOG_PER_CLASS_METRICS=true python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data coco128.yaml \
---weights yolov5s.pt
-```
-
-## Uploading a Dataset to Comet Artifacts
-
-If you would like to store your data using [Comet Artifacts](https://www.comet.com/docs/v2/guides/data-management/using-artifacts/#learn-more?utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github), you can do so using the `upload_dataset` flag.
-
-The dataset be organized in the way described in the [YOLOv5 documentation](https://docs.ultralytics.com/yolov5/tutorials/train_custom_data/). The dataset config `yaml` file must follow the same format as that of the `coco128.yaml` file.
-
-```shell
-python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data coco128.yaml \
---weights yolov5s.pt \
---upload_dataset
-```
-
-You can find the uploaded dataset in the Artifacts tab in your Comet Workspace
-<img width="1073" alt="artifact-1" src="https://user-images.githubusercontent.com/7529846/186929193-162718bf-ec7b-4eb9-8c3b-86b3763ef8ea.png">
-
-You can preview the data directly in the Comet UI.
-<img width="1082" alt="artifact-2" src="https://user-images.githubusercontent.com/7529846/186929215-432c36a9-c109-4eb0-944b-84c2786590d6.png">
-
-Artifacts are versioned and also support adding metadata about the dataset. Comet will automatically log the metadata from your dataset `yaml` file
-<img width="963" alt="artifact-3" src="https://user-images.githubusercontent.com/7529846/186929256-9d44d6eb-1a19-42de-889a-bcbca3018f2e.png">
-
-### Using a saved Artifact
-
-If you would like to use a dataset from Comet Artifacts, set the `path` variable in your dataset `yaml` file to point to the following Artifact resource URL.
-
-```
-# contents of artifact.yaml file
-path: "comet://<workspace name>/<artifact name>:<artifact version or alias>"
-```
-
-Then pass this file to your training script in the following way
-
-```shell
-python train.py \
---img 640 \
---batch 16 \
---epochs 5 \
---data artifact.yaml \
---weights yolov5s.pt
-```
-
-Artifacts also allow you to track the lineage of data as it flows through your Experimentation workflow. Here you can see a graph that shows you all the experiments that have used your uploaded dataset.
-<img width="1391" alt="artifact-4" src="https://user-images.githubusercontent.com/7529846/186929264-4c4014fa-fe51-4f3c-a5c5-f6d24649b1b4.png">
-
-## Resuming a Training Run
-
-If your training run is interrupted for any reason, e.g. disrupted internet connection, you can resume the run using the `resume` flag and the Comet Run Path.
-
-The Run Path has the following format `comet://<your workspace name>/<your project name>/<experiment id>`.
-
-This will restore the run to its state before the interruption, which includes restoring the  model from a checkpoint, restoring all hyperparameters and training arguments and downloading Comet dataset Artifacts if they were used in the original run. The resumed run will continue logging to the existing Experiment in the Comet UI
-
-```shell
-python train.py \
---resume "comet://<your run path>"
-```
-
-## Hyperparameter Search with the Comet Optimizer
-
-YOLOv5 is also integrated with Comet's Optimizer, making is simple to visualize hyperparameter sweeps in the Comet UI.
-
-### Configuring an Optimizer Sweep
-
-To configure the Comet Optimizer, you will have to create a JSON file with the information about the sweep. An example file has been provided in `utils/loggers/comet/optimizer_config.json`
-
-```shell
-python utils/loggers/comet/hpo.py \
-  --comet_optimizer_config "utils/loggers/comet/optimizer_config.json"
-```
-
-The `hpo.py` script accepts the same arguments as `train.py`. If you wish to pass additional arguments to your sweep simply add them after
-the script.
-
-```shell
-python utils/loggers/comet/hpo.py \
-  --comet_optimizer_config "utils/loggers/comet/optimizer_config.json" \
-  --save-period 1 \
-  --bbox_interval 1
-```
-
-### Running a Sweep in Parallel
-
-```shell
-comet optimizer -j <set number of workers> utils/loggers/comet/hpo.py \
-  utils/loggers/comet/optimizer_config.json"
-```
-
-### Visualizing Results
-
-Comet provides a number of ways to visualize the results of your sweep. Take a look at a [project with a completed sweep here](https://www.comet.com/examples/comet-example-yolov5/view/PrlArHGuuhDTKC1UuBmTtOSXD/panels?utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)
-
-<img width="1626" alt="hyperparameter-yolo" src="https://user-images.githubusercontent.com/7529846/186914869-7dc1de14-583f-4323-967b-c9a66a29e495.png">
diff --git a/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/experiment_planning/alternative_experiment_planning/pooling_and_convs/experiment_planner_baseline_3DUNet_poolBasedOnSpacing.py b/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/experiment_planning/alternative_experiment_planning/pooling_and_convs/experiment_planner_baseline_3DUNet_poolBasedOnSpacing.py
deleted file mode 100644
index f99c137dd38f7766a212a656e0e1dcc1d8d33612..0000000000000000000000000000000000000000
--- a/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/experiment_planning/alternative_experiment_planning/pooling_and_convs/experiment_planner_baseline_3DUNet_poolBasedOnSpacing.py
+++ /dev/null
@@ -1,124 +0,0 @@
-#    Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany
-#
-#    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 copy import deepcopy
-
-import numpy as np
-from nnunet.experiment_planning.common_utils import get_pool_and_conv_props
-from nnunet.experiment_planning.experiment_planner_baseline_3DUNet import ExperimentPlanner
-from nnunet.network_architecture.generic_UNet import Generic_UNet
-from nnunet.paths import *
-
-
-class ExperimentPlannerPoolBasedOnSpacing(ExperimentPlanner):
-    def __init__(self, folder_with_cropped_data, preprocessed_output_folder):
-        super(ExperimentPlannerPoolBasedOnSpacing, self).__init__(folder_with_cropped_data, preprocessed_output_folder)
-        self.data_identifier = "nnUNetData_poolBasedOnSpacing"
-        self.plans_fname = join(self.preprocessed_output_folder,
-                                "nnUNetPlans" +  "poolBasedOnSpacing_plans_3D.pkl")
-
-    def get_properties_for_stage(self, current_spacing, original_spacing, original_shape, num_cases,
-                                 num_modalities, num_classes):
-        """
-        ExperimentPlanner configures pooling so that we pool late. Meaning that if the number of pooling per axis is
-        (2, 3, 3), then the first pooling operation will always pool axes 1 and 2 and not 0, irrespective of spacing.
-        This can cause a larger memory footprint, so it can be beneficial to revise this.
-
-        Here we are pooling based on the spacing of the data.
-
-        """
-        new_median_shape = np.round(original_spacing / current_spacing * original_shape).astype(int)
-        dataset_num_voxels = np.prod(new_median_shape) * num_cases
-
-        # the next line is what we had before as a default. The patch size had the same aspect ratio as the median shape of a patient. We swapped t
-        # input_patch_size = new_median_shape
-
-        # compute how many voxels are one mm
-        input_patch_size = 1 / np.array(current_spacing)
-
-        # normalize voxels per mm
-        input_patch_size /= input_patch_size.mean()
-
-        # create an isotropic patch of size 512x512x512mm
-        input_patch_size *= 1 / min(input_patch_size) * 512  # to get a starting value
-        input_patch_size = np.round(input_patch_size).astype(int)
-
-        # clip it to the median shape of the dataset because patches larger then that make not much sense
-        input_patch_size = [min(i, j) for i, j in zip(input_patch_size, new_median_shape)]
-
-        network_num_pool_per_axis, pool_op_kernel_sizes, conv_kernel_sizes, new_shp, \
-        shape_must_be_divisible_by = get_pool_and_conv_props(current_spacing, input_patch_size,
-                                                             self.unet_featuremap_min_edge_length,
-                                                             self.unet_max_numpool)
-
-        ref = Generic_UNet.use_this_for_batch_size_computation_3D
-        here = Generic_UNet.compute_approx_vram_consumption(new_shp, network_num_pool_per_axis,
-                                                            self.unet_base_num_features,
-                                                            self.unet_max_num_filters, num_modalities,
-                                                            num_classes,
-                                                            pool_op_kernel_sizes, conv_per_stage=self.conv_per_stage)
-        while here > ref:
-            axis_to_be_reduced = np.argsort(new_shp / new_median_shape)[-1]
-
-            tmp = deepcopy(new_shp)
-            tmp[axis_to_be_reduced] -= shape_must_be_divisible_by[axis_to_be_reduced]
-            _, _, _, _, shape_must_be_divisible_by_new = \
-                get_pool_and_conv_props(current_spacing, tmp,
-                                        self.unet_featuremap_min_edge_length,
-                                        self.unet_max_numpool,
-                                        )
-            new_shp[axis_to_be_reduced] -= shape_must_be_divisible_by_new[axis_to_be_reduced]
-
-            # we have to recompute numpool now:
-            network_num_pool_per_axis, pool_op_kernel_sizes, conv_kernel_sizes, new_shp, \
-            shape_must_be_divisible_by = get_pool_and_conv_props(current_spacing, new_shp,
-                                                                 self.unet_featuremap_min_edge_length,
-                                                                 self.unet_max_numpool,
-                                                                 )
-
-            here = Generic_UNet.compute_approx_vram_consumption(new_shp, network_num_pool_per_axis,
-                                                                self.unet_base_num_features,
-                                                                self.unet_max_num_filters, num_modalities,
-                                                                num_classes, pool_op_kernel_sizes,
-                                                                conv_per_stage=self.conv_per_stage)
-            print(new_shp)
-
-        input_patch_size = new_shp
-
-        batch_size = Generic_UNet.DEFAULT_BATCH_SIZE_3D  # This is what wirks with 128**3
-        batch_size = int(np.floor(max(ref / here, 1) * batch_size))
-
-        # check if batch size is too large
-        max_batch_size = np.round(self.batch_size_covers_max_percent_of_dataset * dataset_num_voxels /
-                                  np.prod(input_patch_size, dtype=np.int64)).astype(int)
-        max_batch_size = max(max_batch_size, self.unet_min_batch_size)
-        batch_size = max(1, min(batch_size, max_batch_size))
-
-        do_dummy_2D_data_aug = (max(input_patch_size) / input_patch_size[
-            0]) > self.anisotropy_threshold
-
-        plan = {
-            'batch_size': batch_size,
-            'num_pool_per_axis': network_num_pool_per_axis,
-            'patch_size': input_patch_size,
-            'median_patient_size_in_voxels': new_median_shape,
-            'current_spacing': current_spacing,
-            'original_spacing': original_spacing,
-            'do_dummy_2D_data_aug': do_dummy_2D_data_aug,
-            'pool_op_kernel_sizes': pool_op_kernel_sizes,
-            'conv_kernel_sizes': conv_kernel_sizes,
-        }
-        return plan
-
-
diff --git a/spaces/hrishikeshagi/ImagePromptGenerator/app.py b/spaces/hrishikeshagi/ImagePromptGenerator/app.py
deleted file mode 100644
index eaec0ff90c0647efbd68a1958563a44712e0365a..0000000000000000000000000000000000000000
--- a/spaces/hrishikeshagi/ImagePromptGenerator/app.py
+++ /dev/null
@@ -1,139 +0,0 @@
-
-
-
-import os, subprocess
-
-def setup():
-    install_cmds = [
-        ['pip', 'install', 'gradio'],
-        ['pip', 'install', 'open_clip_torch'],
-        ['pip', 'install', 'clip-interrogator'],
-        ['pip', 'install', 'git+https://github.com/pharmapsychotic/BLIP.git'],
-    ]
-    for cmd in install_cmds:
-        print(subprocess.run(cmd, stdout=subprocess.PIPE).stdout.decode('utf-8'))
-
-setup()
-
-
-clip_model_name = 'ViT-L-14/openai' #@param ["ViT-L-14/openai", "ViT-H-14/laion2b_s32b_b79k"]
-
-
-print("Download preprocessed cache files...")
-CACHE_URLS = [
-    'https://huggingface.co/pharma/ci-preprocess/resolve/main/ViT-L-14_openai_artists.pkl',
-    'https://huggingface.co/pharma/ci-preprocess/resolve/main/ViT-L-14_openai_flavors.pkl',
-    'https://huggingface.co/pharma/ci-preprocess/resolve/main/ViT-L-14_openai_mediums.pkl',
-    'https://huggingface.co/pharma/ci-preprocess/resolve/main/ViT-L-14_openai_movements.pkl',
-    'https://huggingface.co/pharma/ci-preprocess/resolve/main/ViT-L-14_openai_trendings.pkl',
-] if clip_model_name == 'ViT-L-14/openai' else [
-    'https://huggingface.co/pharma/ci-preprocess/resolve/main/ViT-H-14_laion2b_s32b_b79k_artists.pkl',
-    'https://huggingface.co/pharma/ci-preprocess/resolve/main/ViT-H-14_laion2b_s32b_b79k_flavors.pkl',
-    'https://huggingface.co/pharma/ci-preprocess/resolve/main/ViT-H-14_laion2b_s32b_b79k_mediums.pkl',
-    'https://huggingface.co/pharma/ci-preprocess/resolve/main/ViT-H-14_laion2b_s32b_b79k_movements.pkl',
-    'https://huggingface.co/pharma/ci-preprocess/resolve/main/ViT-H-14_laion2b_s32b_b79k_trendings.pkl',
-]
-os.makedirs('cache', exist_ok=True)
-for url in CACHE_URLS:
-    print(subprocess.run(['wget', url, '-P', 'cache'], stdout=subprocess.PIPE).stdout.decode('utf-8'))
-
-
-import gradio as gr
-from clip_interrogator import Config, Interrogator
-
-config = Config()
-config.blip_num_beams = 64
-config.blip_offload = False
-config.clip_model_name = clip_model_name
-ci = Interrogator(config)
-
-def inference(image, mode, best_max_flavors=32):
-    ci.config.chunk_size = 2048 if ci.config.clip_model_name == "ViT-L-14/openai" else 1024
-    ci.config.flavor_intermediate_count = 2048 if ci.config.clip_model_name == "ViT-L-14/openai" else 1024
-    image = image.convert('RGB')
-    if mode == 'best':
-        return ci.interrogate(image, max_flavors=int(best_max_flavors))
-    elif mode == 'classic':
-        return ci.interrogate_classic(image)
-    else:
-        return ci.interrogate_fast(image)
-
-#@title Image to prompt! 🖼️ -> 📝
-   
-inputs = [
-    gr.inputs.Image(type='pil'),
-    gr.Radio(['best', 'fast'], label='', value='best'),
-    gr.Number(value=16, label='best mode max flavors'),
-]
-outputs = [
-    gr.outputs.Textbox(label="Output"),
-]
-
-io = gr.Interface(
-    inference, 
-    inputs, 
-    outputs, 
-    allow_flagging=False,
-)
-io.launch(debug=False)
-
-import csv
-import os
-from IPython.display import clear_output, display
-from PIL import Image
-from tqdm import tqdm
-
-folder_path = "/content/my_images" #@param {type:"string"}
-prompt_mode = 'best' #@param ["best","fast"]
-output_mode = 'rename' #@param ["desc.csv","rename"]
-max_filename_len = 128 #@param {type:"integer"}
-best_max_flavors = 16 #@param {type:"integer"}
-
-
-def sanitize_for_filename(prompt: str, max_len: int) -> str:
-    name = "".join(c for c in prompt if (c.isalnum() or c in ",._-! "))
-    name = name.strip()[:(max_len-4)] # extra space for extension
-    return name
-
-ci.config.quiet = True
-
-files = [f for f in os.listdir(folder_path) if f.endswith('.jpg') or f.endswith('.png')] if os.path.exists(folder_path) else []
-prompts = []
-for idx, file in enumerate(tqdm(files, desc='Generating prompts')):
-    if idx > 0 and idx % 100 == 0:
-        clear_output(wait=True)
-
-    image = Image.open(os.path.join(folder_path, file)).convert('RGB')
-    prompt = inference(image, prompt_mode, best_max_flavors=best_max_flavors)
-    prompts.append(prompt)
-
-    print(prompt)
-    thumb = image.copy()
-    thumb.thumbnail([256, 256])
-    display(thumb)
-
-    if output_mode == 'rename':
-        name = sanitize_for_filename(prompt, max_filename_len)
-        ext = os.path.splitext(file)[1]
-        filename = name + ext
-        idx = 1
-        while os.path.exists(os.path.join(folder_path, filename)):
-            print(f'File {filename} already exists, trying {idx+1}...')
-            filename = f"{name}_{idx}{ext}"
-            idx += 1
-        os.rename(os.path.join(folder_path, file), os.path.join(folder_path, filename))
-
-if len(prompts):
-    if output_mode == 'desc.csv':
-        csv_path = os.path.join(folder_path, 'desc.csv')
-        with open(csv_path, 'w', encoding='utf-8', newline='') as f:
-            w = csv.writer(f, quoting=csv.QUOTE_MINIMAL)
-            w.writerow(['image', 'prompt'])
-            for file, prompt in zip(files, prompts):
-                w.writerow([file, prompt])
-
-        print(f"\n\n\n\nGenerated {len(prompts)} prompts and saved to {csv_path}, enjoy!")
-    else:
-        print(f"\n\n\n\nGenerated {len(prompts)} prompts and renamed your files, enjoy!")
-else:
-    print(f"Sorry, I couldn't find any images in {folder_path}")
\ No newline at end of file
diff --git a/spaces/hugggof/vampnet/vampnet/scheduler.py b/spaces/hugggof/vampnet/vampnet/scheduler.py
deleted file mode 100644
index a57108c2af7c974d882b45e092907195ded71c9a..0000000000000000000000000000000000000000
--- a/spaces/hugggof/vampnet/vampnet/scheduler.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import copy
-from typing import List
-
-import torch
-
-class NoamScheduler:
-    """OG scheduler from transformer paper: https://arxiv.org/pdf/1706.03762.pdf
-    Implementation from Annotated Transformer: https://nlp.seas.harvard.edu/2018/04/03/attention.html
-    """
-
-    def __init__(
-        self,
-        optimizer: torch.optim.Optimizer,
-        d_model: int = 512,
-        factor: float = 1.0,
-        warmup: int = 4000,
-    ):
-        # Store hparams
-        self.warmup = warmup
-        self.factor = factor
-        self.d_model = d_model
-
-        # Initialize variables `lr` and `steps`
-        self.lr = None
-        self.steps = 0
-
-        # Store the optimizer
-        self.optimizer = optimizer
-
-    def state_dict(self):
-        return {
-            key: value for key, value in self.__dict__.items() if key != "optimizer"
-        }
-
-    def load_state_dict(self, state_dict):
-        self.__dict__.update(state_dict)
-
-    def step(self):
-        self.steps += 1
-        self.lr = self.factor * (
-            self.d_model ** (-0.5)
-            * min(self.steps ** (-0.5), self.steps * self.warmup ** (-1.5))
-        )
-
-        for p in self.optimizer.param_groups:
-            p["lr"] = self.lr
-
diff --git a/spaces/hzwluoye/gpt4/run.py b/spaces/hzwluoye/gpt4/run.py
deleted file mode 100644
index 65f603f88f4a30ce02fb4f5554d2c5fc6259575d..0000000000000000000000000000000000000000
--- a/spaces/hzwluoye/gpt4/run.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import secrets
-
-from server.bp import bp
-from server.website import Website
-from server.backend import Backend_Api
-from server.babel import create_babel
-from json import load
-from flask import Flask
-
-if __name__ == '__main__':
-
-    # Load configuration from config.json
-    config = load(open('config.json', 'r'))
-    site_config = config['site_config']
-    url_prefix = config.pop('url_prefix')
-
-    # Create the app
-    app = Flask(__name__)
-    app.secret_key = secrets.token_hex(16)
-
-    # Set up Babel
-    create_babel(app)
-
-    # Set up the website routes
-    site = Website(bp, url_prefix)
-    for route in site.routes:
-        bp.add_url_rule(
-            route,
-            view_func=site.routes[route]['function'],
-            methods=site.routes[route]['methods'],
-        )
-
-    # Set up the backend API routes
-    backend_api = Backend_Api(bp, config)
-    for route in backend_api.routes:
-        bp.add_url_rule(
-            route,
-            view_func=backend_api.routes[route]['function'],
-            methods=backend_api.routes[route]['methods'],
-        )
-
-    # Register the blueprint
-    app.register_blueprint(bp, url_prefix=url_prefix)
-
-    # Run the Flask server
-    print(f"Running on {site_config['port']}{url_prefix}")
-    app.run(**site_config)
-    print(f"Closing port {site_config['port']}")
\ No newline at end of file
diff --git a/spaces/hzy123/bingo/src/pages/api/healthz.ts b/spaces/hzy123/bingo/src/pages/api/healthz.ts
deleted file mode 100644
index f6ae44ff0fd66ccd3f7feaa550025fbf2a83bf77..0000000000000000000000000000000000000000
--- a/spaces/hzy123/bingo/src/pages/api/healthz.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-'use server'
-
-import { NextApiRequest, NextApiResponse } from 'next'
-
-export default async function handler(req: NextApiRequest, res: NextApiResponse) {
-  res.status(200).end('ok')
-}
diff --git a/spaces/inamXcontru/PoeticTTS/Corel Draw X5 Crack With Keygen Full Free Download Benefits and Risks.md b/spaces/inamXcontru/PoeticTTS/Corel Draw X5 Crack With Keygen Full Free Download Benefits and Risks.md
deleted file mode 100644
index 81815967f350ac693b46001c11b1f68a72964555..0000000000000000000000000000000000000000
--- a/spaces/inamXcontru/PoeticTTS/Corel Draw X5 Crack With Keygen Full Free Download Benefits and Risks.md	
+++ /dev/null
@@ -1,5 +0,0 @@
-
-<p>Subscribe and save! A CorelDRAW Graphics Suite subscription provides a flexible, affordable way to enjoy the latest software without having to pay the hefty upfront cost of ownership. Instead, you'll get a full-featured, downloadable version of this professional suite with every new release, as long as your subscription is active.</p>
-<h2>Corel Draw X5 Crack With Keygen Full Free Download</h2><br /><p><b><b>Download</b> &mdash;&mdash;&mdash; <a href="https://gohhs.com/2uz4vH">https://gohhs.com/2uz4vH</a></b></p><br /><br /> aaccfb2cb3<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/Astro Vision Lifesign Astrology Software Full Keygen Free Download ((FREE)).md b/spaces/inplisQlawa/anything-midjourney-v4-1/Astro Vision Lifesign Astrology Software Full Keygen Free Download ((FREE)).md
deleted file mode 100644
index c24831cdee57371a60f9dcd6e95e8f8a3d8fd66f..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/Astro Vision Lifesign Astrology Software Full Keygen Free Download ((FREE)).md	
+++ /dev/null
@@ -1,7 +0,0 @@
-
-<p>this software is not only a useful tool but also a great entertainment. a must for those who are into vedic astrology. get the software that can predict your future by using the astrology calculator and the lifeprofiler. you will definitely love this software.features:various types of reports like indian,western,hindu,free,vedic,kundli,birth,lucky,monthly, weekly, daily,and hourly. astrology charts, vedic astrology, kundali, horoscope, matchmaking. best astrology software.no hidden ads. no time limit. support for all windows versions. support for all databases.online support. easy to use and easy to use. free for personal and commercial uses. this software has no time limit. it is not a trial version. it is only a demo. support for all languages. it is not a time limited version. this is lifetime version.</p>
-<h2>Astro Vision Lifesign Astrology Software Full Keygen Free Download</h2><br /><p><b><b>Download Zip</b> &#128504; <a href="https://urlin.us/2uEyjt">https://urlin.us/2uEyjt</a></b></p><br /><br />
-<p>have you used astrology software before? what do you think? did it help you? do you use astrology software on a daily basis? did it help you? why or why not? if you answered yes, then this article is for you. if you answered no, then this article is for you! so, what is the difference between it and other software?.q:what s the difference between astrology software and astrological software.</p>
-<p>tired of looking for the program that you need and you invest hours or maybe days discovering a legitimate working download for programs do you require well you have found the right location! on this blog site you will find programs to make up music, editing photos and videos, modifying games, architecture and far more! here you will find a range of programs you require! download totally free and take pleasure in full cracked programs, license secret, serial key, keygen, activator, cracks, software applications for pc with windows/mac, activation, patches. download link free. you will be satisfied!</p> 899543212b<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/Maladolescenza (1977).md b/spaces/inplisQlawa/anything-midjourney-v4-1/Maladolescenza (1977).md
deleted file mode 100644
index a47f22ab8a05ec1aeb119f308b178986ecd3ef48..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/Maladolescenza (1977).md	
+++ /dev/null
@@ -1,85 +0,0 @@
-<br />
-<h1>Maladolescenza (1977): A Controversial Film About Childhood and Sexuality</h1>
-
-<p>Maladolescenza (German: Spielen wir Liebe) is a 1977 film directed by Pier Giuseppe Murgia. The film caused significant controversy because of its simulated sex scenes involving underage actresses. Because of these scenes, it was banned in several countries, being labeled as child pornography.</p>
-
-<p>The film tells the story of three children: Laura (Lara Wendel), Fabrizio (Martin Loeb), and Sylvia (Eva Ionesco). They spend their summer in a forest, where they explore their sexuality and emotions. Fabrizio is a cruel and manipulative boy who torments Laura and later Sylvia. He kills one of the girls in the end, so she will never leave him.</p>
-<h2>Maladolescenza (1977)</h2><br /><p><b><b>DOWNLOAD</b> &#128504; <a href="https://urlin.us/2uEvHH">https://urlin.us/2uEvHH</a></b></p><br /><br />
-
-<p>The film was intended to be a poetic and artistic depiction of the dark side of innocence and the loss of childhood. However, it was widely criticized for its explicit and disturbing content, especially the nudity and sexual acts of the young actresses. The film was banned or censored in many countries, such as Germany, Italy, France, Canada, Australia, and the United States. It was also subject to legal actions and protests from various groups and individuals.</p>
-
-<h2>The Making of Maladolescenza (1977)</h2>
-
-<p>Maladolescenza (1977) was based on a novel by Peter Berling, who also co-wrote the screenplay with Murgia. The film was produced by Franco Cancellieri and shot in Italy and Germany. The film had a low budget and a small crew. The director used natural lighting and locations to create a realistic and intimate atmosphere.</p>
-
-<p>The casting of the three main actors was controversial. Lara Wendel was 12 years old at the time of filming, Eva Ionesco was 11, and Martin Loeb was 18. Wendel and Ionesco were both models who had posed nude for magazines before. Ionesco was also the daughter of Irina Ionesco, a famous photographer who took erotic pictures of her since she was four years old.</p>
-
-<p>The director claimed that he had the consent of the parents and the actors for the sex scenes. He also said that he used body doubles and special effects to make them look more realistic. However, some critics and viewers doubted his claims and accused him of exploiting and abusing the young actresses.</p>
-
-<h2>The Reception of Maladolescenza (1977)</h2>
-
-<p>Maladolescenza (1977) premiered in Italy on December 18, 1977. It received mixed reviews from critics and audiences. Some praised it for its artistic value and its exploration of taboo topics. Others condemned it for its immoral and illegal content and its negative influence on society.</p>
-
-<p>The film faced legal troubles in many countries where it was released or attempted to be released. In Germany, it was banned by the Federal Department for Media Harmful to Young Persons in 1980. In Italy, it was seized by the authorities in 1981 and later declared obscene by the Supreme Court in 1984. In France, it was rated X by the censorship board in 1979 and later re-rated 18 by a court order in 1983. In Canada, it was banned by customs in 1980 and later confiscated by the police in 1984. In Australia, it was refused classification by the censorship board in 1980 and later banned by a court order in 1984. In the United States, it was never officially released, but it was shown at some film festivals and underground screenings.</p>
-<p></p>
-
-<p>The film also sparked protests and debates from various groups and individuals who opposed or supported it. Some feminist groups denounced it as a misogynist and pedophilic film that violated the rights of women and children. Some religious groups condemned it as a blasphemous and immoral film that corrupted the morals of society. Some artistic groups defended it as a masterpiece of cinema that challenged the norms and conventions of society.</p>
-
-<h2>The Legacy of Maladolescenza (1977)</h2>
-
-<p>Maladolescenza (1977) is considered one of the most controversial films ever made. It has been subject to numerous studies and analyses by scholars, critics, and filmmakers. It has also influenced many other films that deal with similar themes or styles, such as Pretty Baby (1978), The Blue Lagoon (1980), Nenè (1977), Bilitis (1977), Beau-père (1981), L'Amant (1992), Lolita (1997), Ken Park (2002), Mysterious Skin (2004), Thirteen (2003), Kids (1995), Bully (2001), Elephant (2003), Dogtooth (2009), We Need to Talk About Kevin (2011), The Tribe (2014), Mustang (2015), The Florida Project (2017), Cuties (2020), etc.</p>
-
-<p>The film has also been subject to various adaptations and remakes by different directors</p>
-<h2>Maladolescenza (1977): A Forbidden Love Triangle Between Three Children</h2>
-
-<p>Maladolescenza (1977) is a film that explores the complex and controversial relationship between three children: Laura, Fabrizio, and Sylvia. The film shows how they experience love, jealousy, betrayal, and violence in their isolated and idyllic forest.</p>
-
-<p>Laura is a shy and innocent girl who falls in love with Fabrizio, a handsome and charismatic boy who lives in the forest with his dog. Fabrizio is a sadistic and manipulative boy who enjoys torturing Laura and making her suffer. He seduces her in a cave and then abandons her for Sylvia, a beautiful and confident girl who arrives in the forest with her parents.</p>
-
-<p>Sylvia is a spoiled and arrogant girl who knows how to use her charm and sexuality to get what she wants. She becomes Fabrizio's lover and accomplice, joining him in his cruel games against Laura. She also tries to dominate him and make him jealous by flirting with other boys.</p>
-
-<p>The film depicts the sexual awakening and experimentation of the three children, as well as their psychological and emotional turmoil. The film also portrays the contrast between their innocent appearance and their corrupted behavior, as well as the contrast between the natural beauty of the forest and the human ugliness of their actions.</p>
-
-<h2>Maladolescenza (1977): A Shocking and Disturbing Film That Explores the Dark Side of Innocence</h2>
-
-<p>Maladolescenza (1977) is a film that shocked and disturbed many viewers and critics with its graphic and explicit depiction of underage sexuality and violence. The film features several scenes of nudity, masturbation, oral sex, intercourse, rape, and murder involving the young actors.</p>
-
-<p>The film was accused of being child pornography and exploitation by many people who considered it immoral and illegal. The film was banned or censored in many countries, such as Germany, Italy, France, Canada, Australia, and the United States. The film was also subject to legal actions and protests from various groups and individuals.</p>
-
-<p>The director defended his film as an artistic expression of his vision and his message. He claimed that he wanted to show the reality of childhood and adolescence, as well as the dangers of society's repression and hypocrisy. He also claimed that he had the consent of the parents and the actors for the sex scenes, and that he used body doubles and special effects to make them look more realistic.</p>
-
-<p>The film has been praised by some critics and filmmakers who recognized its artistic value and its courage to challenge the norms and conventions of society. The film has been compared to other controversial films that deal with similar themes or styles, such as Lolita (1962), Salò (1975), A Clockwork Orange (1971), The Last House on the Left (1972), etc.</p>
-<h2>Maladolescenza (1977): A Controversial Film About Childhood and Sexuality</h2>
-
-<p>Maladolescenza (German: Spielen wir Liebe) is a 1977 film directed by Pier Giuseppe Murgia. The film caused significant controversy because of its simulated sex scenes involving underage actresses. Because of these scenes, it was banned in several countries, being labeled as child pornography.</p>
-
-<p>The film tells the story of three children: Laura (Lara Wendel), Fabrizio (Martin Loeb), and Sylvia (Eva Ionesco). They spend their summer in a forest, where they explore their sexuality and emotions. Fabrizio is a cruel and manipulative boy who torments Laura and later Sylvia. He kills one of the girls in the end, so she will never leave him.</p>
-
-<p>The film was intended to be a poetic and artistic depiction of the dark side of innocence and the loss of childhood. However, it was widely criticized for its explicit and disturbing content, especially the nudity and sexual acts of the young actresses. The film was banned or censored in many countries, such as Germany, Italy, France, Canada, Australia, and the United States. It was also subject to legal actions and protests from various groups and individuals.</p>
-
-<h2>The Story Behind Maladolescenza (1977): How a 1977 Movie Sparked Outrage and Censorship</h2>
-
-<p>Maladolescenza (1977) was based on a novel by Peter Berling, who also co-wrote the screenplay with Murgia. The film was produced by Franco Cancellieri and shot in Italy and Germany. The film had a low budget and a small crew. The director used natural lighting and locations to create a realistic and intimate atmosphere.</p>
-
-<p>The casting of the three main actors was controversial. Lara Wendel was 12 years old at the time of filming, Eva Ionesco was 11, and Martin Loeb was 18. Wendel and Ionesco were both models who had posed nude for magazines before. Ionesco was also the daughter of Irina Ionesco, a famous photographer who took erotic pictures of her since she was four years old.</p>
-
-<p>The director claimed that he had the consent of the parents and the actors for the sex scenes. He also said that he used body doubles and special effects to make them look more realistic. However, some critics and viewers doubted his claims and accused him of exploiting and abusing the young actresses.</p>
-
-<p>The film premiered in Italy on December 18, 1977. It received mixed reviews from critics and audiences. Some praised it for its artistic value and its exploration of taboo topics. Others condemned it for its immoral and illegal content and its negative influence on society.</p>
-
-<p>The film faced legal troubles in many countries where it was released or attempted to be released. In Germany, it was banned by the Federal Department for Media Harmful to Young Persons in 1980. In Italy, it was seized by the authorities in 1981 and later declared obscene by the Supreme Court in 1984. In France, it was rated X by the censorship board in 1979 and later re-rated 18 by a court order in 1983. In Canada, it was banned by customs in 1980 and later confiscated by the police in 1984. In Australia, it was refused classification by the censorship board in 1980 and later banned by a court order in 1984. In the United States, it was never officially released, but it was shown at some film festivals and underground screenings.</p>
-
-<p>The film also sparked protests and debates from various groups and individuals who opposed or supported it. Some feminist groups denounced it as a misogynist and pedophilic film that violated the rights of women and children. Some religious groups condemned it as a blasphemous
-<h2>Maladolescenza (1977): A Controversial Film That Challenges the Norms and Conventions of Society</h2>
-
-<p>Maladolescenza (1977) is a film that shocked and disturbed many viewers and critics with its graphic and explicit depiction of underage sexuality and violence. The film features three children who experience love, jealousy, betrayal, and violence in their isolated and idyllic forest.</p>
-
-<p>The film was intended to be a poetic and artistic depiction of the dark side of innocence and the loss of childhood. However, it was widely criticized for its immoral and illegal content and its negative influence on society. The film was banned or censored in many countries, being labeled as child pornography. The film was also subject to legal actions and protests from various groups and individuals.</p>
-
-<p>The film has been praised by some critics and filmmakers who recognized its artistic value and its courage to challenge the norms and conventions of society. The film has been compared to other controversial films that deal with similar themes or styles, such as Lolita (1962), Salò (1975), A Clockwork Orange (1971), The Last House on the Left (1972), etc.</p>
-
-<p>The film has also been subject to various adaptations and remakes by different directors and countries, such as Playing with Love (1978) by David Hamilton, Maladolescenza: Forbidden Love (1996) by Bruno Mattei, Maladolescenza: Love Games (2000) by Roger A. Fratter, etc.</p>
-
-<p>Maladolescenza (1977) is a film that explores the complex and controversial relationship between three children: Laura, Fabrizio, and Sylvia. The film shows how they experience love, jealousy, betrayal, and violence in their isolated and idyllic forest. The film also portrays the contrast between their innocent appearance and their corrupted behavior, as well as the contrast between the natural beauty of the forest and the human ugliness of their actions.</p> 3cee63e6c2<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/inreVtussa/clothingai/Examples/City Car Driving Home Edition Crack Free Download.md b/spaces/inreVtussa/clothingai/Examples/City Car Driving Home Edition Crack Free Download.md
deleted file mode 100644
index 56b03ee0f9874b3841e31a53b7a0d6b620e374ff..0000000000000000000000000000000000000000
--- a/spaces/inreVtussa/clothingai/Examples/City Car Driving Home Edition Crack Free Download.md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>city car driving home edition crack free download</h2><br /><p><b><b>Download File</b> &middot;&middot;&middot; <a href="https://tiurll.com/2uCj2y">https://tiurll.com/2uCj2y</a></b></p><br /><br />
-<br />
- d5da3c52bf<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/inreVtussa/clothingai/Examples/Custom Maid 3d English Patch.md b/spaces/inreVtussa/clothingai/Examples/Custom Maid 3d English Patch.md
deleted file mode 100644
index 8c79a410dd77af54ced3913a55f71709ec16a22e..0000000000000000000000000000000000000000
--- a/spaces/inreVtussa/clothingai/Examples/Custom Maid 3d English Patch.md	
+++ /dev/null
@@ -1,33 +0,0 @@
-
-<h1>How to Install and Use Custom Maid 3d English Patch</h1>
-<p>Custom Maid 3d (CM3D2) is a popular Japanese game that allows you to create and customize your own maids and interact with them in various scenarios. However, the game is only available in Japanese, which can be a barrier for many players who want to enjoy it. Fortunately, there are ways to install and use an English patch that can translate most of the game's content into English.</p>
-<h2>Custom Maid 3d English Patch</h2><br /><p><b><b>Download File</b> &#10040; <a href="https://tiurll.com/2uCj88">https://tiurll.com/2uCj88</a></b></p><br /><br />
-<p>In this article, we will show you how to install and use Custom Maid 3d English Patch, which is based on the work of various translators and modders from the community. This patch can translate the game's interface, menus, dialogs, events, and more. It can also add some features and fixes that can improve your gaming experience.</p>
-<h2>Requirements</h2>
-<p>Before you install and use Custom Maid 3d English Patch, you need to have the following:</p>
-<ul>
-<li>A copy of Custom Maid 3d (CM3D2) installed on your PC. You can buy it from <a href="https://dlsoft.dmm.co.jp/en/detail/kiss_0001/">DMM</a> or <a href="https://www.amazon.co.jp/-/en/KISS-Custom-Maid-3D2-Windows/dp/B00U8Q8E0K">Amazon Japan</a>.</li>
-<li>A copy of Custom Order Maid 3d (COM3D2) installed on your PC. This is an optional but recommended step, as it can add more content and features to CM3D2. You can buy it from <a href="https://dlsoft.dmm.co.jp/en/detail/kiss_0002/">DMM</a> or <a href="https://www.amazon.co.jp/-/en/KISS-Custom-Order-Maid-3D2/dp/B07B4Z9X5F">Amazon Japan</a>.</li>
-<li>A copy of Sybaris II AIO for CM3D2/COM3D2. This is a modding framework that can enable various plugins and mods for the game. You can download it from <a href="https://github.com/Neerhom/Sybaris/releases">GitHub</a>.</li>
-<li>A copy of CM3D2 HF-Patch v131.0. This is a collection of plugins and mods that can translate and enhance the game. You can download it from <a href="https://sukebei.nyaa.si/view/3526981">Sukebei</a>.</li>
-<li>A copy of YATranslator for CM3D2/COM3D2. This is a plugin that can translate the game's text on the fly using Google Translate or other online services. You can download it from <a href="https://github.com/denikson/CM3D2.YATranslator/releases">GitHub</a>.</li>
-</ul>
-<h2>Installation</h2>
-<p>To install and use Custom Maid 3d English Patch, follow these steps:</p>
-<p></p>
-<ol>
-<li>Extract the contents of Sybaris II AIO for CM3D2/COM3D2 into your CM3D2 or COM3D2 game folder.</li>
-<li>Extract the contents of CM3D2 HF-Patch v131.0 into your CM3D2 or COM3D2 game folder.</li>
-<li>Extract the contents of YATranslator for CM3D2/COM3D2 into your CM3D2 or COM3D2 game folder.</li>
-<li>Run the game using CM3D2x64.exe or COM3D2x64.exe.</li>
-<li>Enjoy the game in English!</li>
-</ol>
-<h2>Troubleshooting</h2>
-<p>If you encounter any problems or errors while installing or using Custom Maid 3d English Patch, you can try the following solutions:</p>
-<ul>
-<li>Make sure you have installed all the required components correctly.</li>
-<li>Make sure you have updated your game to the latest version.</li>
-<li>Make sure you have a stable internet connection for YATranslator to work properly.</li>
-<li>Make sure you have selected English as your preferred language in YATranslator settings</p> d5da3c52bf<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/iqovocn/ChuanhuChatGPT/ChuanhuChatbot.py b/spaces/iqovocn/ChuanhuChatGPT/ChuanhuChatbot.py
deleted file mode 100644
index 890e5c7ec70f26a0452ded3e33cd56f488819932..0000000000000000000000000000000000000000
--- a/spaces/iqovocn/ChuanhuChatGPT/ChuanhuChatbot.py
+++ /dev/null
@@ -1,473 +0,0 @@
-# -*- coding:utf-8 -*-
-import os
-import logging
-import sys
-
-import gradio as gr
-
-from modules import config
-from modules.config import *
-from modules.utils import *
-from modules.presets import *
-from modules.overwrites import *
-from modules.models.models import get_model
-
-logging.getLogger("httpx").setLevel(logging.WARNING)
-
-gr.Chatbot._postprocess_chat_messages = postprocess_chat_messages
-gr.Chatbot.postprocess = postprocess
-
-with open("assets/custom.css", "r", encoding="utf-8") as f:
-    customCSS = f.read()
-
-def create_new_model():
-    return get_model(model_name = MODELS[DEFAULT_MODEL], access_key = my_api_key)[0]
-
-with gr.Blocks(css=customCSS, theme=small_and_beautiful_theme) as demo:
-    user_name = gr.State("")
-    promptTemplates = gr.State(load_template(get_template_names(plain=True)[0], mode=2))
-    user_question = gr.State("")
-    assert type(my_api_key)==str
-    user_api_key = gr.State(my_api_key)
-    current_model = gr.State(create_new_model)
-
-    topic = gr.State(i18n("未命名对话历史记录"))
-
-    with gr.Row():
-        gr.HTML(CHUANHU_TITLE, elem_id="app_title")
-        status_display = gr.Markdown(get_geoip(), elem_id="status_display")
-    with gr.Row(elem_id="float_display"):
-        user_info = gr.Markdown(value="getting user info...", elem_id="user_info")
-
-    with gr.Row().style(equal_height=True):
-        with gr.Column(scale=5):
-            with gr.Row():
-                chatbot = gr.Chatbot(label="Chuanhu Chat", elem_id="chuanhu_chatbot").style(height="100%")
-            with gr.Row():
-                with gr.Column(min_width=225, scale=12):
-                    user_input = gr.Textbox(
-                        elem_id="user_input_tb",
-                        show_label=False, placeholder=i18n("在这里输入")
-                    ).style(container=False)
-                with gr.Column(min_width=42, scale=1):
-                    submitBtn = gr.Button(value="", variant="primary", elem_id="submit_btn")
-                    cancelBtn = gr.Button(value="", variant="secondary", visible=False, elem_id="cancel_btn")
-            with gr.Row():
-                emptyBtn = gr.Button(
-                    i18n("🧹 新的对话"), elem_id="empty_btn"
-                )
-                retryBtn = gr.Button(i18n("🔄 重新生成"))
-                delFirstBtn = gr.Button(i18n("🗑️ 删除最旧对话"))
-                delLastBtn = gr.Button(i18n("🗑️ 删除最新对话"))
-                with gr.Row(visible=False) as like_dislike_area:
-                    with gr.Column(min_width=20, scale=1):
-                        likeBtn = gr.Button(i18n("👍"))
-                    with gr.Column(min_width=20, scale=1):
-                        dislikeBtn = gr.Button(i18n("👎"))
-
-        with gr.Column():
-            with gr.Column(min_width=50, scale=1):
-                with gr.Tab(label=i18n("模型")):
-                    keyTxt = gr.Textbox(
-                        show_label=True,
-                        placeholder=f"Your API-key...",
-                        value=hide_middle_chars(user_api_key.value),
-                        type="password",
-                        visible=not HIDE_MY_KEY,
-                        label="API-Key",
-                    )
-                    if multi_api_key:
-                        usageTxt = gr.Markdown(i18n("多账号模式已开启，无需输入key，可直接开始对话"), elem_id="usage_display", elem_classes="insert_block")
-                    else:
-                        usageTxt = gr.Markdown(i18n("**发送消息** 或 **提交key** 以显示额度"), elem_id="usage_display", elem_classes="insert_block")
-                    model_select_dropdown = gr.Dropdown(
-                        label=i18n("选择模型"), choices=MODELS, multiselect=False, value=MODELS[DEFAULT_MODEL], interactive=True
-                    )
-                    lora_select_dropdown = gr.Dropdown(
-                        label=i18n("选择LoRA模型"), choices=[], multiselect=False, interactive=True, visible=False
-                    )
-                    with gr.Row():
-                        single_turn_checkbox = gr.Checkbox(label=i18n("单轮对话"), value=False)
-                        use_websearch_checkbox = gr.Checkbox(label=i18n("使用在线搜索"), value=False)
-                    language_select_dropdown = gr.Dropdown(
-                        label=i18n("选择回复语言（针对搜索&索引功能）"),
-                        choices=REPLY_LANGUAGES,
-                        multiselect=False,
-                        value=REPLY_LANGUAGES[0],
-                    )
-                    index_files = gr.Files(label=i18n("上传"), type="file")
-                    two_column = gr.Checkbox(label=i18n("双栏pdf"), value=advance_docs["pdf"].get("two_column", False))
-                    summarize_btn = gr.Button(i18n("总结"))
-                    # TODO: 公式ocr
-                    # formula_ocr = gr.Checkbox(label=i18n("识别公式"), value=advance_docs["pdf"].get("formula_ocr", False))
-
-                with gr.Tab(label="Prompt"):
-                    systemPromptTxt = gr.Textbox(
-                        show_label=True,
-                        placeholder=i18n("在这里输入System Prompt..."),
-                        label="System prompt",
-                        value=INITIAL_SYSTEM_PROMPT,
-                        lines=10,
-                    ).style(container=False)
-                    with gr.Accordion(label=i18n("加载Prompt模板"), open=True):
-                        with gr.Column():
-                            with gr.Row():
-                                with gr.Column(scale=6):
-                                    templateFileSelectDropdown = gr.Dropdown(
-                                        label=i18n("选择Prompt模板集合文件"),
-                                        choices=get_template_names(plain=True),
-                                        multiselect=False,
-                                        value=get_template_names(plain=True)[0],
-                                    ).style(container=False)
-                                with gr.Column(scale=1):
-                                    templateRefreshBtn = gr.Button(i18n("🔄 刷新"))
-                            with gr.Row():
-                                with gr.Column():
-                                    templateSelectDropdown = gr.Dropdown(
-                                        label=i18n("从Prompt模板中加载"),
-                                        choices=load_template(
-                                            get_template_names(plain=True)[0], mode=1
-                                        ),
-                                        multiselect=False,
-                                    ).style(container=False)
-
-                with gr.Tab(label=i18n("保存/加载")):
-                    with gr.Accordion(label=i18n("保存/加载对话历史记录"), open=True):
-                        with gr.Column():
-                            with gr.Row():
-                                with gr.Column(scale=6):
-                                    historyFileSelectDropdown = gr.Dropdown(
-                                        label=i18n("从列表中加载对话"),
-                                        choices=get_history_names(plain=True),
-                                        multiselect=False
-                                    )
-                                with gr.Column(scale=1):
-                                    historyRefreshBtn = gr.Button(i18n("🔄 刷新"))
-                            with gr.Row():
-                                with gr.Column(scale=6):
-                                    saveFileName = gr.Textbox(
-                                        show_label=True,
-                                        placeholder=i18n("设置文件名: 默认为.json，可选为.md"),
-                                        label=i18n("设置保存文件名"),
-                                        value=i18n("对话历史记录"),
-                                    ).style(container=True)
-                                with gr.Column(scale=1):
-                                    saveHistoryBtn = gr.Button(i18n("💾 保存对话"))
-                                    exportMarkdownBtn = gr.Button(i18n("📝 导出为Markdown"))
-                                    gr.Markdown(i18n("默认保存于history文件夹"))
-                            with gr.Row():
-                                with gr.Column():
-                                    downloadFile = gr.File(interactive=True)
-
-                with gr.Tab(label=i18n("高级")):
-                    gr.Markdown(i18n("# ⚠️ 务必谨慎更改 ⚠️\n\n如果无法使用请恢复默认设置"))
-                    gr.HTML(get_html("appearance_switcher.html").format(label=i18n("切换亮暗色主题")), elem_classes="insert_block")
-                    use_streaming_checkbox = gr.Checkbox(
-                            label=i18n("实时传输回答"), value=True, visible=ENABLE_STREAMING_OPTION
-                        )
-                    with gr.Accordion(i18n("参数"), open=False):
-                        temperature_slider = gr.Slider(
-                            minimum=-0,
-                            maximum=2.0,
-                            value=1.0,
-                            step=0.1,
-                            interactive=True,
-                            label="temperature",
-                        )
-                        top_p_slider = gr.Slider(
-                            minimum=-0,
-                            maximum=1.0,
-                            value=1.0,
-                            step=0.05,
-                            interactive=True,
-                            label="top-p",
-                        )
-                        n_choices_slider = gr.Slider(
-                            minimum=1,
-                            maximum=10,
-                            value=1,
-                            step=1,
-                            interactive=True,
-                            label="n choices",
-                        )
-                        stop_sequence_txt = gr.Textbox(
-                            show_label=True,
-                            placeholder=i18n("在这里输入停止符，用英文逗号隔开..."),
-                            label="stop",
-                            value="",
-                            lines=1,
-                        )
-                        max_context_length_slider = gr.Slider(
-                            minimum=1,
-                            maximum=32768,
-                            value=2000,
-                            step=1,
-                            interactive=True,
-                            label="max context",
-                        )
-                        max_generation_slider = gr.Slider(
-                            minimum=1,
-                            maximum=32768,
-                            value=1000,
-                            step=1,
-                            interactive=True,
-                            label="max generations",
-                        )
-                        presence_penalty_slider = gr.Slider(
-                            minimum=-2.0,
-                            maximum=2.0,
-                            value=0.0,
-                            step=0.01,
-                            interactive=True,
-                            label="presence penalty",
-                        )
-                        frequency_penalty_slider = gr.Slider(
-                            minimum=-2.0,
-                            maximum=2.0,
-                            value=0.0,
-                            step=0.01,
-                            interactive=True,
-                            label="frequency penalty",
-                        )
-                        logit_bias_txt = gr.Textbox(
-                            show_label=True,
-                            placeholder=f"word:likelihood",
-                            label="logit bias",
-                            value="",
-                            lines=1,
-                        )
-                        user_identifier_txt = gr.Textbox(
-                            show_label=True,
-                            placeholder=i18n("用于定位滥用行为"),
-                            label=i18n("用户名"),
-                            value=user_name.value,
-                            lines=1,
-                        )
-
-                    with gr.Accordion(i18n("网络设置"), open=False, visible=False):
-                        # 优先展示自定义的api_host
-                        apihostTxt = gr.Textbox(
-                            show_label=True,
-                            placeholder=i18n("在这里输入API-Host..."),
-                            label="API-Host",
-                            value=config.api_host or shared.API_HOST,
-                            lines=1,
-                        )
-                        changeAPIURLBtn = gr.Button(i18n("🔄 切换API地址"))
-                        proxyTxt = gr.Textbox(
-                            show_label=True,
-                            placeholder=i18n("在这里输入代理地址..."),
-                            label=i18n("代理地址（示例：http://127.0.0.1:10809）"),
-                            value="",
-                            lines=2,
-                        )
-                        changeProxyBtn = gr.Button(i18n("🔄 设置代理地址"))
-                        default_btn = gr.Button(i18n("🔙 恢复默认设置"))
-
-    gr.Markdown(CHUANHU_DESCRIPTION, elem_id="description")
-    gr.HTML(get_html("footer.html").format(versions=versions_html()), elem_id="footer")
-
-    # https://github.com/gradio-app/gradio/pull/3296
-    def create_greeting(request: gr.Request):
-        if hasattr(request, "username") and request.username: # is not None or is not ""
-            logging.info(f"Get User Name: {request.username}")
-            user_info, user_name = gr.Markdown.update(value=f"User: {request.username}"), request.username
-        else:
-            user_info, user_name = gr.Markdown.update(value=f"", visible=False), ""
-        current_model = get_model(model_name = MODELS[DEFAULT_MODEL], access_key = my_api_key)[0]
-        current_model.set_user_identifier(user_name)
-        chatbot = gr.Chatbot.update(label=MODELS[DEFAULT_MODEL])
-        return user_info, user_name, current_model, toggle_like_btn_visibility(DEFAULT_MODEL), *current_model.auto_load(), get_history_names(False, user_name), chatbot
-    demo.load(create_greeting, inputs=None, outputs=[user_info, user_name, current_model, like_dislike_area, systemPromptTxt, chatbot, historyFileSelectDropdown, chatbot], api_name="load")
-    chatgpt_predict_args = dict(
-        fn=predict,
-        inputs=[
-            current_model,
-            user_question,
-            chatbot,
-            use_streaming_checkbox,
-            use_websearch_checkbox,
-            index_files,
-            language_select_dropdown,
-        ],
-        outputs=[chatbot, status_display],
-        show_progress=True,
-    )
-
-    start_outputing_args = dict(
-        fn=start_outputing,
-        inputs=[],
-        outputs=[submitBtn, cancelBtn],
-        show_progress=True,
-    )
-
-    end_outputing_args = dict(
-        fn=end_outputing, inputs=[], outputs=[submitBtn, cancelBtn]
-    )
-
-    reset_textbox_args = dict(
-        fn=reset_textbox, inputs=[], outputs=[user_input]
-    )
-
-    transfer_input_args = dict(
-        fn=transfer_input, inputs=[user_input], outputs=[user_question, user_input, submitBtn, cancelBtn], show_progress=True
-    )
-
-    get_usage_args = dict(
-        fn=billing_info, inputs=[current_model], outputs=[usageTxt], show_progress=False
-    )
-
-    load_history_from_file_args = dict(
-        fn=load_chat_history,
-        inputs=[current_model, historyFileSelectDropdown, user_name],
-        outputs=[saveFileName, systemPromptTxt, chatbot]
-    )
-
-
-    # Chatbot
-    cancelBtn.click(interrupt, [current_model], [])
-
-    user_input.submit(**transfer_input_args).then(**chatgpt_predict_args).then(**end_outputing_args)
-    user_input.submit(**get_usage_args)
-
-    submitBtn.click(**transfer_input_args).then(**chatgpt_predict_args, api_name="predict").then(**end_outputing_args)
-    submitBtn.click(**get_usage_args)
-
-    index_files.change(handle_file_upload, [current_model, index_files, chatbot, language_select_dropdown], [index_files, chatbot, status_display])
-    summarize_btn.click(handle_summarize_index, [current_model, index_files, chatbot, language_select_dropdown], [chatbot, status_display])
-
-    emptyBtn.click(
-        reset,
-        inputs=[current_model],
-        outputs=[chatbot, status_display],
-        show_progress=True,
-    )
-
-    retryBtn.click(**start_outputing_args).then(
-        retry,
-        [
-            current_model,
-            chatbot,
-            use_streaming_checkbox,
-            use_websearch_checkbox,
-            index_files,
-            language_select_dropdown,
-        ],
-        [chatbot, status_display],
-        show_progress=True,
-    ).then(**end_outputing_args)
-    retryBtn.click(**get_usage_args)
-
-    delFirstBtn.click(
-        delete_first_conversation,
-        [current_model],
-        [status_display],
-    )
-
-    delLastBtn.click(
-        delete_last_conversation,
-        [current_model, chatbot],
-        [chatbot, status_display],
-        show_progress=False
-    )
-
-    likeBtn.click(
-        like,
-        [current_model],
-        [status_display],
-        show_progress=False
-    )
-
-    dislikeBtn.click(
-        dislike,
-        [current_model],
-        [status_display],
-        show_progress=False
-    )
-
-    two_column.change(update_doc_config, [two_column], None)
-
-    # LLM Models
-    keyTxt.change(set_key, [current_model, keyTxt], [user_api_key, status_display], api_name="set_key").then(**get_usage_args)
-    keyTxt.submit(**get_usage_args)
-    single_turn_checkbox.change(set_single_turn, [current_model, single_turn_checkbox], None)
-    model_select_dropdown.change(get_model, [model_select_dropdown, lora_select_dropdown, user_api_key, temperature_slider, top_p_slider, systemPromptTxt, user_name], [current_model, status_display, chatbot, lora_select_dropdown], show_progress=True, api_name="get_model")
-    model_select_dropdown.change(toggle_like_btn_visibility, [model_select_dropdown], [like_dislike_area], show_progress=False)
-    lora_select_dropdown.change(get_model, [model_select_dropdown, lora_select_dropdown, user_api_key, temperature_slider, top_p_slider, systemPromptTxt, user_name], [current_model, status_display, chatbot], show_progress=True)
-
-    # Template
-    systemPromptTxt.change(set_system_prompt, [current_model, systemPromptTxt], None)
-    templateRefreshBtn.click(get_template_names, None, [templateFileSelectDropdown])
-    templateFileSelectDropdown.change(
-        load_template,
-        [templateFileSelectDropdown],
-        [promptTemplates, templateSelectDropdown],
-        show_progress=True,
-    )
-    templateSelectDropdown.change(
-        get_template_content,
-        [promptTemplates, templateSelectDropdown, systemPromptTxt],
-        [systemPromptTxt],
-        show_progress=True,
-    )
-
-    # S&L
-    saveHistoryBtn.click(
-        save_chat_history,
-        [current_model, saveFileName, chatbot, user_name],
-        downloadFile,
-        show_progress=True,
-    )
-    saveHistoryBtn.click(get_history_names, [gr.State(False), user_name], [historyFileSelectDropdown])
-    exportMarkdownBtn.click(
-        export_markdown,
-        [current_model, saveFileName, chatbot, user_name],
-        downloadFile,
-        show_progress=True,
-    )
-    historyRefreshBtn.click(get_history_names, [gr.State(False), user_name], [historyFileSelectDropdown])
-    historyFileSelectDropdown.change(**load_history_from_file_args)
-    downloadFile.change(upload_chat_history, [current_model, downloadFile, user_name], [saveFileName, systemPromptTxt, chatbot])
-
-    # Advanced
-    max_context_length_slider.change(set_token_upper_limit, [current_model, max_context_length_slider], None)
-    temperature_slider.change(set_temperature, [current_model, temperature_slider], None)
-    top_p_slider.change(set_top_p, [current_model, top_p_slider], None)
-    n_choices_slider.change(set_n_choices, [current_model, n_choices_slider], None)
-    stop_sequence_txt.change(set_stop_sequence, [current_model, stop_sequence_txt], None)
-    max_generation_slider.change(set_max_tokens, [current_model, max_generation_slider], None)
-    presence_penalty_slider.change(set_presence_penalty, [current_model, presence_penalty_slider], None)
-    frequency_penalty_slider.change(set_frequency_penalty, [current_model, frequency_penalty_slider], None)
-    logit_bias_txt.change(set_logit_bias, [current_model, logit_bias_txt], None)
-    user_identifier_txt.change(set_user_identifier, [current_model, user_identifier_txt], None)
-
-    default_btn.click(
-        reset_default, [], [apihostTxt, proxyTxt, status_display], show_progress=True
-    )
-    changeAPIURLBtn.click(
-        change_api_host,
-        [apihostTxt],
-        [status_display],
-        show_progress=True,
-    )
-    changeProxyBtn.click(
-        change_proxy,
-        [proxyTxt],
-        [status_display],
-        show_progress=True,
-    )
-
-logging.info(
-    colorama.Back.GREEN
-    + "\n川虎的温馨提示：访问 http://localhost:7860 查看界面"
-    + colorama.Style.RESET_ALL
-)
-# 默认开启本地服务器，默认可以直接从IP访问，默认不创建公开分享链接
-demo.title = i18n("川虎Chat 🚀")
-
-if __name__ == "__main__":
-    reload_javascript()
-    demo.queue(concurrency_count=CONCURRENT_COUNT).launch(
-        blocked_paths=["config.json"],
-        favicon_path="./assets/favicon.ico"
-    )
diff --git a/spaces/issenn/so-vits-svc-4.0-spaces-sample/style.css b/spaces/issenn/so-vits-svc-4.0-spaces-sample/style.css
deleted file mode 100644
index fd2871e207941fa775e2f8b8f80b7029684056cb..0000000000000000000000000000000000000000
--- a/spaces/issenn/so-vits-svc-4.0-spaces-sample/style.css
+++ /dev/null
@@ -1,11 +0,0 @@
-
-/* general styled components */
-
-.gradio-button.tool{
-    max-width: 2.2em;
-    min-width: 2.2em !important;
-    height: 2.4em;
-    align-self: end;
-    line-height: 1em;
-    border-radius: 0.5em;
-}
diff --git a/spaces/jackli888/stable-diffusion-webui/modules/interrogate.py b/spaces/jackli888/stable-diffusion-webui/modules/interrogate.py
deleted file mode 100644
index 236abe516c8783824b6aecaae188a31cfa17f75c..0000000000000000000000000000000000000000
--- a/spaces/jackli888/stable-diffusion-webui/modules/interrogate.py
+++ /dev/null
@@ -1,227 +0,0 @@
-import os
-import sys
-import traceback
-from collections import namedtuple
-from pathlib import Path
-import re
-
-import torch
-import torch.hub
-
-from torchvision import transforms
-from torchvision.transforms.functional import InterpolationMode
-
-import modules.shared as shared
-from modules import devices, paths, shared, lowvram, modelloader, errors
-
-blip_image_eval_size = 384
-clip_model_name = 'ViT-L/14'
-
-Category = namedtuple("Category", ["name", "topn", "items"])
-
-re_topn = re.compile(r"\.top(\d+)\.")
-
-def category_types():
-    return [f.stem for f in Path(shared.interrogator.content_dir).glob('*.txt')]
-
-
-def download_default_clip_interrogate_categories(content_dir):
-    print("Downloading CLIP categories...")
-
-    tmpdir = content_dir + "_tmp"
-    category_types = ["artists", "flavors", "mediums", "movements"]
-
-    try:
-        os.makedirs(tmpdir)
-        for category_type in category_types:
-            torch.hub.download_url_to_file(f"https://raw.githubusercontent.com/pharmapsychotic/clip-interrogator/main/clip_interrogator/data/{category_type}.txt", os.path.join(tmpdir, f"{category_type}.txt"))
-        os.rename(tmpdir, content_dir)
-
-    except Exception as e:
-        errors.display(e, "downloading default CLIP interrogate categories")
-    finally:
-        if os.path.exists(tmpdir):
-            os.remove(tmpdir)
-
-
-class InterrogateModels:
-    blip_model = None
-    clip_model = None
-    clip_preprocess = None
-    dtype = None
-    running_on_cpu = None
-
-    def __init__(self, content_dir):
-        self.loaded_categories = None
-        self.skip_categories = []
-        self.content_dir = content_dir
-        self.running_on_cpu = devices.device_interrogate == torch.device("cpu")
-
-    def categories(self):
-        if not os.path.exists(self.content_dir):
-            download_default_clip_interrogate_categories(self.content_dir)
-
-        if self.loaded_categories is not None and self.skip_categories == shared.opts.interrogate_clip_skip_categories:
-           return self.loaded_categories
-
-        self.loaded_categories = []
-
-        if os.path.exists(self.content_dir):
-            self.skip_categories = shared.opts.interrogate_clip_skip_categories
-            category_types = []
-            for filename in Path(self.content_dir).glob('*.txt'):
-                category_types.append(filename.stem)
-                if filename.stem in self.skip_categories:
-                    continue
-                m = re_topn.search(filename.stem)
-                topn = 1 if m is None else int(m.group(1))
-                with open(filename, "r", encoding="utf8") as file:
-                    lines = [x.strip() for x in file.readlines()]
-
-                self.loaded_categories.append(Category(name=filename.stem, topn=topn, items=lines))
-
-        return self.loaded_categories
-
-    def create_fake_fairscale(self):
-        class FakeFairscale:
-            def checkpoint_wrapper(self):
-                pass
-
-        sys.modules["fairscale.nn.checkpoint.checkpoint_activations"] = FakeFairscale
-
-    def load_blip_model(self):
-        self.create_fake_fairscale()
-        import models.blip
-
-        files = modelloader.load_models(
-            model_path=os.path.join(paths.models_path, "BLIP"),
-            model_url='https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_caption_capfilt_large.pth',
-            ext_filter=[".pth"],
-            download_name='model_base_caption_capfilt_large.pth',
-        )
-
-        blip_model = models.blip.blip_decoder(pretrained=files[0], image_size=blip_image_eval_size, vit='base', med_config=os.path.join(paths.paths["BLIP"], "configs", "med_config.json"))
-        blip_model.eval()
-
-        return blip_model
-
-    def load_clip_model(self):
-        import clip
-
-        if self.running_on_cpu:
-            model, preprocess = clip.load(clip_model_name, device="cpu", download_root=shared.cmd_opts.clip_models_path)
-        else:
-            model, preprocess = clip.load(clip_model_name, download_root=shared.cmd_opts.clip_models_path)
-
-        model.eval()
-        model = model.to(devices.device_interrogate)
-
-        return model, preprocess
-
-    def load(self):
-        if self.blip_model is None:
-            self.blip_model = self.load_blip_model()
-            if not shared.cmd_opts.no_half and not self.running_on_cpu:
-                self.blip_model = self.blip_model.half()
-
-        self.blip_model = self.blip_model.to(devices.device_interrogate)
-
-        if self.clip_model is None:
-            self.clip_model, self.clip_preprocess = self.load_clip_model()
-            if not shared.cmd_opts.no_half and not self.running_on_cpu:
-                self.clip_model = self.clip_model.half()
-
-        self.clip_model = self.clip_model.to(devices.device_interrogate)
-
-        self.dtype = next(self.clip_model.parameters()).dtype
-
-    def send_clip_to_ram(self):
-        if not shared.opts.interrogate_keep_models_in_memory:
-            if self.clip_model is not None:
-                self.clip_model = self.clip_model.to(devices.cpu)
-
-    def send_blip_to_ram(self):
-        if not shared.opts.interrogate_keep_models_in_memory:
-            if self.blip_model is not None:
-                self.blip_model = self.blip_model.to(devices.cpu)
-
-    def unload(self):
-        self.send_clip_to_ram()
-        self.send_blip_to_ram()
-
-        devices.torch_gc()
-
-    def rank(self, image_features, text_array, top_count=1):
-        import clip
-
-        devices.torch_gc()
-
-        if shared.opts.interrogate_clip_dict_limit != 0:
-            text_array = text_array[0:int(shared.opts.interrogate_clip_dict_limit)]
-
-        top_count = min(top_count, len(text_array))
-        text_tokens = clip.tokenize([text for text in text_array], truncate=True).to(devices.device_interrogate)
-        text_features = self.clip_model.encode_text(text_tokens).type(self.dtype)
-        text_features /= text_features.norm(dim=-1, keepdim=True)
-
-        similarity = torch.zeros((1, len(text_array))).to(devices.device_interrogate)
-        for i in range(image_features.shape[0]):
-            similarity += (100.0 * image_features[i].unsqueeze(0) @ text_features.T).softmax(dim=-1)
-        similarity /= image_features.shape[0]
-
-        top_probs, top_labels = similarity.cpu().topk(top_count, dim=-1)
-        return [(text_array[top_labels[0][i].numpy()], (top_probs[0][i].numpy()*100)) for i in range(top_count)]
-
-    def generate_caption(self, pil_image):
-        gpu_image = transforms.Compose([
-            transforms.Resize((blip_image_eval_size, blip_image_eval_size), interpolation=InterpolationMode.BICUBIC),
-            transforms.ToTensor(),
-            transforms.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711))
-        ])(pil_image).unsqueeze(0).type(self.dtype).to(devices.device_interrogate)
-
-        with torch.no_grad():
-            caption = self.blip_model.generate(gpu_image, sample=False, num_beams=shared.opts.interrogate_clip_num_beams, min_length=shared.opts.interrogate_clip_min_length, max_length=shared.opts.interrogate_clip_max_length)
-
-        return caption[0]
-
-    def interrogate(self, pil_image):
-        res = ""
-        shared.state.begin()
-        shared.state.job = 'interrogate'
-        try:
-            if shared.cmd_opts.lowvram or shared.cmd_opts.medvram:
-                lowvram.send_everything_to_cpu()
-                devices.torch_gc()
-
-            self.load()
-
-            caption = self.generate_caption(pil_image)
-            self.send_blip_to_ram()
-            devices.torch_gc()
-
-            res = caption
-
-            clip_image = self.clip_preprocess(pil_image).unsqueeze(0).type(self.dtype).to(devices.device_interrogate)
-
-            with torch.no_grad(), devices.autocast():
-                image_features = self.clip_model.encode_image(clip_image).type(self.dtype)
-
-                image_features /= image_features.norm(dim=-1, keepdim=True)
-
-                for name, topn, items in self.categories():
-                    matches = self.rank(image_features, items, top_count=topn)
-                    for match, score in matches:
-                        if shared.opts.interrogate_return_ranks:
-                            res += f", ({match}:{score/100:.3f})"
-                        else:
-                            res += ", " + match
-
-        except Exception:
-            print("Error interrogating", file=sys.stderr)
-            print(traceback.format_exc(), file=sys.stderr)
-            res += "<error>"
-
-        self.unload()
-        shared.state.end()
-
-        return res
diff --git a/spaces/jackyccl/segment-anything/groundingdino/datasets/__init__.py b/spaces/jackyccl/segment-anything/groundingdino/datasets/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/james-oldfield/PandA/networks/genforce/runners/optimizer.py b/spaces/james-oldfield/PandA/networks/genforce/runners/optimizer.py
deleted file mode 100644
index 15ab801d9f046268328f6f06dd3e78720ebece62..0000000000000000000000000000000000000000
--- a/spaces/james-oldfield/PandA/networks/genforce/runners/optimizer.py
+++ /dev/null
@@ -1,237 +0,0 @@
-# python3.7
-"""Contains the function to build optimizer for runner."""
-
-import math
-
-import torch
-
-__all__ = ['build_optimizer', 'build_optimizers']
-
-_ALLOWED_OPT_TYPES = ['SGD', 'ADAM']
-
-
-def build_optimizer(config, model):
-    """Builds an optimizer for the given model.
-
-    Basically, the configuration is expected to contain following settings:
-
-    (1) opt_type: The type of the optimizer. (required)
-    (2) base_lr: The base learning rate for all parameters. (required)
-    (3) base_wd: The base weight decay for all parameters. (default: 0.0)
-    (4) bias_lr_multiplier: The learning rate multiplier for bias parameters.
-        (default: 1.0)
-    (5) bias_wd_multiplier: The weight decay multiplier for bias parameters.
-        (default: 1.0)
-    (6) **kwargs: Additional settings for the optimizer, such as `momentum`.
-
-    Args:
-        config: The configuration used to build the optimizer.
-        model: The model which the optimizer serves.
-
-    Returns:
-        A `torch.optim.Optimizer`.
-
-    Raises:
-        ValueError: The `opt_type` is not supported.
-        NotImplementedError: If `opt_type` is not implemented.
-    """
-    assert isinstance(config, dict)
-    opt_type = config['opt_type'].upper()
-    base_lr = config['base_lr']
-    base_wd = config.get('base_wd', 0.0)
-    bias_lr_multiplier = config.get('bias_lr_multiplier', 1.0)
-    bias_wd_multiplier = config.get('bias_wd_multiplier', 1.0)
-
-    if opt_type not in _ALLOWED_OPT_TYPES:
-        raise ValueError(f'Invalid optimizer type `{opt_type}`!'
-                         f'Allowed types: {_ALLOWED_OPT_TYPES}.')
-
-    model_params = []
-    for param_name, param in model.named_parameters():
-        param_group = {'params': [param]}
-        if param.requires_grad:
-            if 'bias' in param_name:
-                param_group['lr'] = base_lr * bias_lr_multiplier
-                param_group['weight_decay'] = base_wd * bias_wd_multiplier
-            else:
-                param_group['lr'] = base_lr
-                param_group['weight_decay'] = base_wd
-        model_params.append(param_group)
-
-    if opt_type == 'SGD':
-        return torch.optim.SGD(params=model_params,
-                               lr=base_lr,
-                               momentum=config.get('momentum', 0.9),
-                               dampening=config.get('dampening', 0),
-                               weight_decay=base_wd,
-                               nesterov=config.get('nesterov', False))
-    if opt_type == 'ADAM':
-        return AdamOptimizer(params=model_params,
-                             lr=base_lr,
-                             betas=config.get('betas', (0.9, 0.999)),
-                             eps=config.get('eps', 1e-8),
-                             weight_decay=base_wd,
-                             amsgrad=config.get('amsgrad', False))
-    raise NotImplementedError(f'Not implemented optimizer type `{opt_type}`!')
-
-
-def build_optimizers(opt_config, runner):
-    """Builds optimizers for the given runner.
-
-    The `opt_config` should be a dictionary, where keys are model names and
-    each value is the optimizer configuration for a particumar model. All built
-    optimizers will be saved in `runner.optimizers`, which is also a dictionary.
-
-    NOTE: The model names should match the keys of `runner.models`.
-
-    Args:
-        opt_config: The configuration to build the optimizers.
-        runner: The runner to build the optimizer for.
-    """
-    if not opt_config:
-        return
-
-    assert isinstance(opt_config, dict)
-    for name, config in opt_config.items():
-        if not name or not config:
-            continue
-        if name in runner.optimizers:
-            raise AttributeError(f'Optimizer `{name}` has already existed!')
-        if name not in runner.models:
-            raise AttributeError(f'Model `{name}` is missing!')
-        runner.optimizers[name] = build_optimizer(config, runner.models[name])
-
-
-# We slightly modify the Adam optimizer from `torch.optim`. since there exists
-# some discrepancies between the `torch.optim` version and the TensorFlow
-# version. The main difference is where to add the `epsilon`.
-# TODO: The modified optimizer does not support `amsgrad` any more.
-
-# pylint: disable=line-too-long
-# pylint: disable=unneeded-not
-# pylint: disable=misplaced-comparison-constant
-# pylint: disable=super-with-arguments
-
-class AdamOptimizer(torch.optim.Optimizer):
-    r"""Implements Adam algorithm.
-
-    It has been proposed in `Adam: A Method for Stochastic Optimization`_.
-    The implementation of the L2 penalty follows changes proposed in
-    `Decoupled Weight Decay Regularization`_.
-
-    Arguments:
-        params (iterable): iterable of parameters to optimize or dicts defining
-            parameter groups
-        lr (float, optional): learning rate (default: 1e-3)
-        betas (Tuple[float, float], optional): coefficients used for computing
-            running averages of gradient and its square (default: (0.9, 0.999))
-        eps (float, optional): term added to the denominator to improve
-            numerical stability (default: 1e-8)
-        weight_decay (float, optional): weight decay (L2 penalty) (default: 0)
-        amsgrad (boolean, optional): whether to use the AMSGrad variant of this
-            algorithm from the paper `On the Convergence of Adam and Beyond`_
-            (default: False)
-
-    .. _Adam\: A Method for Stochastic Optimization:
-        https://arxiv.org/abs/1412.6980
-    .. _Decoupled Weight Decay Regularization:
-        https://arxiv.org/abs/1711.05101
-    .. _On the Convergence of Adam and Beyond:
-        https://openreview.net/forum?id=ryQu7f-RZ
-    """
-
-    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8,
-                 weight_decay=0, amsgrad=False):
-        if not 0.0 <= lr:
-            raise ValueError("Invalid learning rate: {}".format(lr))
-        if not 0.0 <= eps:
-            raise ValueError("Invalid epsilon value: {}".format(eps))
-        if not 0.0 <= betas[0] < 1.0:
-            raise ValueError("Invalid beta parameter at index 0: {}".format(betas[0]))
-        if not 0.0 <= betas[1] < 1.0:
-            raise ValueError("Invalid beta parameter at index 1: {}".format(betas[1]))
-        if not 0.0 <= weight_decay:
-            raise ValueError("Invalid weight_decay value: {}".format(weight_decay))
-        defaults = dict(lr=lr, betas=betas, eps=eps,
-                        weight_decay=weight_decay, amsgrad=amsgrad)
-        super(AdamOptimizer, self).__init__(params, defaults)
-
-    def __setstate__(self, state):
-        super(AdamOptimizer, self).__setstate__(state)
-        for group in self.param_groups:
-            group.setdefault('amsgrad', False)
-
-    @torch.no_grad()
-    def step(self, closure=None):
-        """Performs a single optimization step.
-
-        Arguments:
-            closure (callable, optional): A closure that reevaluates the model
-                and returns the loss.
-        """
-        loss = None
-        if closure is not None:
-            with torch.enable_grad():
-                loss = closure()
-
-        for group in self.param_groups:
-            for p in group['params']:
-                if p.grad is None:
-                    continue
-                grad = p.grad
-                if grad.is_sparse:
-                    raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')
-                amsgrad = group['amsgrad']
-                assert not amsgrad
-
-                state = self.state[p]
-
-                # State initialization
-                if len(state) == 0:
-                    state['step'] = 0
-                    # Exponential moving average of gradient values
-                    state['exp_avg'] = torch.zeros_like(p, memory_format=torch.preserve_format)
-                    # Exponential moving average of squared gradient values
-                    state['exp_avg_sq'] = torch.zeros_like(p, memory_format=torch.preserve_format)
-                    if amsgrad:
-                        # Maintains max of all exp. moving avg. of sq. grad. values
-                        state['max_exp_avg_sq'] = torch.zeros_like(p, memory_format=torch.preserve_format)
-
-                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
-                # if amsgrad:
-                #     max_exp_avg_sq = state['max_exp_avg_sq']
-                beta1, beta2 = group['betas']
-
-                state['step'] += 1
-                bias_correction1 = 1 - beta1 ** state['step']
-                bias_correction2 = 1 - beta2 ** state['step']
-
-                if group['weight_decay'] != 0:
-                    grad = grad.add(p, alpha=group['weight_decay'])
-
-                # Decay the first and second moment running average coefficient
-                exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
-                exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
-
-                # if amsgrad:
-                #     # Maintains the maximum of all 2nd moment running avg. till now
-                #     torch.maximum(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)
-                #     # Use the max. for normalizing running avg. of gradient
-                #     denom = (max_exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])
-                # else:
-                #     denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])
-
-                # step_size = group['lr'] / bias_correction1
-
-                # p.addcdiv_(exp_avg, denom, value=-step_size)
-
-                step_size = group['lr'] * math.sqrt(bias_correction2) / bias_correction1
-
-                p.addcdiv_(exp_avg, exp_avg_sq.sqrt().add_(group['eps']) , value=-step_size)
-
-        return loss
-
-# pylint: enable=line-too-long
-# pylint: enable=unneeded-not
-# pylint: enable=misplaced-comparison-constant
-# pylint: enable=super-with-arguments
diff --git a/spaces/james-oldfield/PandA/networks/genforce/utils/logger.py b/spaces/james-oldfield/PandA/networks/genforce/utils/logger.py
deleted file mode 100644
index b3a0aac64fa4a81f1f27c81c2c94915051da3e24..0000000000000000000000000000000000000000
--- a/spaces/james-oldfield/PandA/networks/genforce/utils/logger.py
+++ /dev/null
@@ -1,356 +0,0 @@
-# python3.7
-"""Utility functions for logging."""
-
-import os
-import sys
-import logging
-from tqdm import tqdm
-from rich.console import Console
-from rich.logging import RichHandler
-from rich.progress import Progress
-from rich.progress import ProgressColumn
-from rich.progress import TextColumn
-from rich.progress import BarColumn
-from rich.text import Text
-
-__all__ = ['build_logger', 'Logger', 'RichLogger', 'DumbLogger']
-
-DEFAULT_WORK_DIR = 'work_dirs'
-
-_LOGGER_TYPES = ['normal', 'rich', 'dumb']
-
-
-def build_logger(logger_type='normal', **kwargs):
-    """Builds a logger.
-
-    Supported Logger types:
-        `normal`: The default logger.
-        `rich`: Record messages with decoration, using `rich` module.
-        `dumb`: Do NOT record any message.
-
-    Args:
-        logger_type: Type of logger, which is case insensitive.
-            (default: `normal`)
-        **kwargs: Additional arguments.
-    """
-    assert isinstance(logger_type, str)
-    logger_type = logger_type.lower()
-    if logger_type not in _LOGGER_TYPES:
-        raise ValueError(f'Invalid logger type `{logger_type}`!\n'
-                         f'Types allowed: {_LOGGER_TYPES}.')
-    if logger_type == 'normal':
-        return Logger(**kwargs)
-    if logger_type == 'rich':
-        return RichLogger(**kwargs)
-    if logger_type == 'dumb':
-        return DumbLogger(**kwargs)
-    raise NotImplementedError(f'Not implemented logger type `{logger_type}`!')
-
-
-class Logger(object):
-    """Defines a logger to record log message both on screen and to file.
-
-    The class sets up a logger with `DEBUG` log level. Two handlers will be
-    added to the logger. One is the `sys.stderr` stream, with `INFO` log level,
-    which will print improtant messages on the screen. The other is used to save
-    all messages to file `$WORK_DIR/$LOGFILE_NAME`. Messages will be added time
-    stamp and log level before logged.
-
-    NOTE: If `logfile_name` is empty, the file stream will be skipped.
-    """
-
-    def __init__(self,
-                 work_dir=DEFAULT_WORK_DIR,
-                 logfile_name='log.txt',
-                 logger_name='logger'):
-        """Initializes the logger.
-
-        Args:
-            work_dir: The work directory. (default: DEFAULT_WORK_DIR)
-            logfile_name: Name of the log file. (default: `log.txt`)
-            logger_name: Unique name for the logger. (default: `logger`)
-        """
-        self.logger = logging.getLogger(logger_name)
-        self.logger.propagate = False
-        if self.logger.hasHandlers():  # Already existed
-            raise SystemExit(f'Logger `{logger_name}` has already existed!\n'
-                             f'Please use another name, or otherwise the '
-                             f'messages from these two logger may be mixed up.')
-
-        self.logger.setLevel(logging.DEBUG)
-        formatter = logging.Formatter(
-            '[%(asctime)s][%(levelname)s] %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S')
-
-        # Print log message with `INFO` level or above onto the screen.
-        terminal_handler = logging.StreamHandler(stream=sys.stdout)
-        terminal_handler.setLevel(logging.INFO)
-        terminal_handler.setFormatter(formatter)
-        self.logger.addHandler(terminal_handler)
-
-        # Save log message with all levels into log file if needed.
-        if logfile_name:
-            os.makedirs(work_dir, exist_ok=True)
-            self.file_stream = open(os.path.join(work_dir, logfile_name), 'a')
-            file_handler = logging.StreamHandler(stream=self.file_stream)
-            file_handler.setLevel(logging.DEBUG)
-            file_handler.setFormatter(formatter)
-            self.logger.addHandler(file_handler)
-
-        self.log = self.logger.log
-        self.debug = self.logger.debug
-        self.info = self.logger.info
-        self.warning = self.logger.warning
-        self.error = self.logger.error
-        self.exception = self.logger.exception
-        self.critical = self.logger.critical
-
-        self.pbar = []
-        self.pbar_kwargs = None
-
-    def __del__(self):
-        if hasattr(self, 'file_stream'):
-            self.file_stream.close()
-
-    def print(self, *messages, **_unused_kwargs):
-        """Prints messages without time stamp or log level."""
-        for handler in self.logger.handlers:
-            print(*messages, file=handler.stream)
-
-    def init_pbar(self, leave=False):
-        """Initializes a progress bar which will display on the screen only.
-
-        Args:
-            leave: Whether to leave the trace. (default: False)
-        """
-        columns = [
-            '{desc}',
-            '{bar}',
-            ' {percentage:5.1f}%',
-            '[{elapsed}<{remaining}, {rate_fmt}{postfix}]',
-        ]
-        self.pbar_kwargs = dict(
-            leave=leave,
-            bar_format=' '.join(columns),
-            unit='',
-        )
-
-    def add_pbar_task(self, name, total):
-        """Adds a task to the progress bar.
-
-        Args:
-            name: Name of the new task.
-            total: Total number of steps (samples) contained in the task.
-
-        Returns:
-            The task ID.
-        """
-        assert isinstance(self.pbar_kwargs, dict)
-        self.pbar.append(tqdm(desc=name, total=total, **self.pbar_kwargs))
-        return len(self.pbar) - 1
-
-    def update_pbar(self, task_id, advance=1):
-        """Updates a certain task in the progress bar.
-
-        Args:
-            task_id: ID of the task to update.
-            advance: Number of steps advanced onto the target task. (default: 1)
-        """
-        assert len(self.pbar) > task_id and isinstance(self.pbar[task_id], tqdm)
-        if self.pbar[task_id].n < self.pbar[task_id].total:
-            self.pbar[task_id].update(advance)
-            if self.pbar[task_id].n >= self.pbar[task_id].total:
-                self.pbar[task_id].refresh()
-
-    def close_pbar(self):
-        """Closes the progress bar"""
-        for pbar in self.pbar[::-1]:
-            pbar.close()
-        self.pbar.clear()
-        self.pbar_kwargs = None
-
-
-def _format_time(seconds):
-    """Formats seconds to readable time string.
-
-    This function is used to display time in progress bar.
-    """
-    if not seconds:
-        return '--:--'
-
-    seconds = int(seconds)
-    hours, seconds = divmod(seconds, 3600)
-    minutes, seconds = divmod(seconds, 60)
-    if hours:
-        return f'{hours}:{minutes:02d}:{seconds:02d}'
-    return f'{minutes:02d}:{seconds:02d}'
-
-
-class TimeColumn(ProgressColumn):
-    """Renders total time, ETA, and speed in progress bar."""
-
-    max_refresh = 0.5  # Only refresh twice a second to prevent jitter
-
-    def render(self, task):
-        elapsed_time = _format_time(task.elapsed)
-        eta = _format_time(task.time_remaining)
-        speed = f'{task.speed:.2f}/s' if task.speed else '?/s'
-        return Text(f'[{elapsed_time}<{eta}, {speed}]',
-                    style="progress.remaining")
-
-
-class RichLogger(object):
-    """Defines a logger based on `rich.RichHandler`.
-
-    Compared to the basic Logger, this logger will decorate the log message in
-    a pretty format automatically.
-    """
-
-    def __init__(self,
-                 work_dir=DEFAULT_WORK_DIR,
-                 logfile_name='log.txt',
-                 logger_name='logger'):
-        """Initializes the logger.
-
-        Args:
-            work_dir: The work directory. (default: DEFAULT_WORK_DIR)
-            logfile_name: Name of the log file. (default: `log.txt`)
-            logger_name: Unique name for the logger. (default: `logger`)
-        """
-        self.logger = logging.getLogger(logger_name)
-        self.logger.propagate = False
-        if self.logger.hasHandlers():  # Already existed
-            raise SystemExit(f'Logger `{logger_name}` has already existed!\n'
-                             f'Please use another name, or otherwise the '
-                             f'messages from these two logger may be mixed up.')
-
-        self.logger.setLevel(logging.DEBUG)
-
-        # Print log message with `INFO` level or above onto the screen.
-        terminal_console = Console(
-            file=sys.stderr, log_time=False, log_path=False)
-        terminal_handler = RichHandler(
-            level=logging.INFO,
-            console=terminal_console,
-            show_time=True,
-            show_level=True,
-            show_path=False)
-        terminal_handler.setFormatter(logging.Formatter('%(message)s'))
-        self.logger.addHandler(terminal_handler)
-
-        # Save log message with all levels into log file if needed.
-        if logfile_name:
-            os.makedirs(work_dir, exist_ok=True)
-            self.file_stream = open(os.path.join(work_dir, logfile_name), 'a')
-            file_console = Console(
-                file=self.file_stream, log_time=False, log_path=False)
-            file_handler = RichHandler(
-                level=logging.DEBUG,
-                console=file_console,
-                show_time=True,
-                show_level=True,
-                show_path=False)
-            file_handler.setFormatter(logging.Formatter('%(message)s'))
-            self.logger.addHandler(file_handler)
-
-        self.log = self.logger.log
-        self.debug = self.logger.debug
-        self.info = self.logger.info
-        self.warning = self.logger.warning
-        self.error = self.logger.error
-        self.exception = self.logger.exception
-        self.critical = self.logger.critical
-
-        self.pbar = None
-
-    def __del__(self):
-        if hasattr(self, 'file_stream'):
-            self.file_stream.close()
-
-    def print(self, *messages, **kwargs):
-        """Prints messages without time stamp or log level."""
-        for handler in self.logger.handlers:
-            handler.console.print(*messages, **kwargs)
-
-    def init_pbar(self, leave=False):
-        """Initializes a progress bar which will display on the screen only.
-
-        Args:
-            leave: Whether to leave the trace. (default: False)
-        """
-        assert self.pbar is None
-
-        # Columns shown in the progress bar.
-        columns = (
-            TextColumn("[progress.description]{task.description}"),
-            BarColumn(bar_width=None),
-            TextColumn("[progress.percentage]{task.percentage:>5.1f}%"),
-            TimeColumn(),
-        )
-
-        self.pbar = Progress(*columns,
-                             console=self.logger.handlers[0].console,
-                             transient=not leave,
-                             auto_refresh=True,
-                             refresh_per_second=10)
-        self.pbar.start()
-
-    def add_pbar_task(self, name, total):
-        """Adds a task to the progress bar.
-
-        Args:
-            name: Name of the new task.
-            total: Total number of steps (samples) contained in the task.
-
-        Returns:
-            The task ID.
-        """
-        assert isinstance(self.pbar, Progress)
-        task_id = self.pbar.add_task(name, total=total)
-        return task_id
-
-    def update_pbar(self, task_id, advance=1):
-        """Updates a certain task in the progress bar.
-
-        Args:
-            task_id: ID of the task to update.
-            advance: Number of steps advanced onto the target task. (default: 1)
-        """
-        assert isinstance(self.pbar, Progress)
-        if self.pbar.tasks[int(task_id)].finished:
-            if self.pbar.tasks[int(task_id)].stop_time is None:
-                self.pbar.stop_task(task_id)
-        else:
-            self.pbar.update(task_id, advance=advance)
-
-    def close_pbar(self):
-        """Closes the progress bar"""
-        assert isinstance(self.pbar, Progress)
-        self.pbar.stop()
-        self.pbar = None
-
-
-class DumbLogger(object):
-    """Implements a dumb logger.
-
-    This logger also has member functions like `info()`, `warning()`, etc. But
-    nothing will be logged.
-    """
-
-    def __init__(self, *_unused_args, **_unused_kwargs):
-        """Initializes with dumb functions."""
-        self.logger = None
-        self.log = lambda *args, **kwargs: None
-        self.debug = lambda *args, **kwargs: None
-        self.info = lambda *args, **kwargs: None
-        self.warning = lambda *args, **kwargs: None
-        self.error = lambda *args, **kwargs: None
-        self.exception = lambda *args, **kwargs: None
-        self.critical = lambda *args, **kwargs: None
-        self.print = lambda *args, **kwargs: None
-
-        self.pbar = None
-        self.init_pbar = lambda *args, **kwargs: None
-        self.add_pbar_task = lambda *args, **kwargs: -1
-        self.update_pbar = lambda *args, **kwargs: None
-        self.close_pbar = lambda *args, **kwargs: None
diff --git a/spaces/jbilcke-hf/VideoChain-UI/src/server/README.md b/spaces/jbilcke-hf/VideoChain-UI/src/server/README.md
deleted file mode 100644
index 08c40293860e4b6558403a470706098d95b2b190..0000000000000000000000000000000000000000
--- a/spaces/jbilcke-hf/VideoChain-UI/src/server/README.md
+++ /dev/null
@@ -1 +0,0 @@
-All those files and functions are server for server-side use only.
\ No newline at end of file
diff --git a/spaces/jbilcke-hf/ai-comic-factory/src/lib/getImageDimension.ts b/spaces/jbilcke-hf/ai-comic-factory/src/lib/getImageDimension.ts
deleted file mode 100644
index 50a94ae1eee733b23b1d4916780e597c759c608e..0000000000000000000000000000000000000000
--- a/spaces/jbilcke-hf/ai-comic-factory/src/lib/getImageDimension.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-export interface ImageDimension {
-  width: number
-  height: number
-}
-
-export async function getImageDimension(src: string): Promise<ImageDimension> {
-  if (!src) {
-    return { width: 0, height: 0 }
-  }
-  const img = new Image()
-  img.src = src
-  await img.decode()
-  const width = img.width
-  const height = img.height
-  return { width, height }
-}
\ No newline at end of file
diff --git a/spaces/jdczlx/ChatGPT-chuanhu/custom.css b/spaces/jdczlx/ChatGPT-chuanhu/custom.css
deleted file mode 100644
index 5143eb138ea2469d8c457c71cb210fd3fb7cbe15..0000000000000000000000000000000000000000
--- a/spaces/jdczlx/ChatGPT-chuanhu/custom.css
+++ /dev/null
@@ -1,162 +0,0 @@
-:root {
-    --chatbot-color-light: #F3F3F3;
-    --chatbot-color-dark: #121111;
-}
-
-/* status_display */
-#status_display {
-    display: flex;
-    min-height: 2.5em;
-    align-items: flex-end;
-    justify-content: flex-end;
-}
-#status_display p {
-    font-size: .85em;
-    font-family: monospace;
-    color: var(--body-text-color-subdued);
-}
-
-#chuanhu_chatbot, #status_display {
-    transition: all 0.6s;
-}
-/* list */
-ol:not(.options), ul:not(.options) {
-    padding-inline-start: 2em !important;
-}
-
-/* 亮色 */
-#chuanhu_chatbot {
-    background-color: var(--chatbot-color-light) !important;
-}
-[data-testid = "bot"] {
-    background-color: #FFFFFF !important;
-}
-[data-testid = "user"] {
-    background-color: #95EC69 !important;
-}
-/* 对话气泡 */
-[class *= "message"] {
-    border-radius: var(--radius-xl) !important;
-    border: none;
-    padding: var(--spacing-xl) !important;
-    font-size: var(--text-md) !important;
-    line-height: var(--line-md) !important;
-    min-height: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
-    min-width: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
-}
-[data-testid = "bot"] {
-    max-width: 85%;
-    border-bottom-left-radius: 0 !important;
-}
-[data-testid = "user"] {
-    max-width: 85%;
-    width: auto !important;
-    border-bottom-right-radius: 0 !important;
-}
-/* 表格 */
-table {
-    margin: 1em 0;
-    border-collapse: collapse;
-    empty-cells: show;
-}
-td,th {
-    border: 1.2px solid var(--border-color-primary) !important;
-    padding: 0.2em;
-}
-thead {
-    background-color: rgba(175,184,193,0.2);
-}
-thead th {
-    padding: .5em .2em;
-}
-/* 行内代码 */
-code {
-    display: inline;
-    white-space: break-spaces;
-    border-radius: 6px;
-    margin: 0 2px 0 2px;
-    padding: .2em .4em .1em .4em;
-    background-color: rgba(175,184,193,0.2);
-}
-/* 代码块 */
-pre code {
-    display: block;
-    overflow: auto;
-    white-space: pre;
-    background-color: hsla(0, 0%, 0%, 80%)!important;
-    border-radius: 10px;
-    padding: 1.4em 1.2em 0em 1.4em;
-    margin: 1.2em 2em 1.2em 0.5em;
-    color: #FFF;
-    box-shadow: 6px 6px 16px hsla(0, 0%, 0%, 0.2);
-}
-/* 代码高亮样式 */
-.highlight .hll { background-color: #49483e }
-.highlight .c { color: #75715e } /* Comment */
-.highlight .err { color: #960050; background-color: #1e0010 } /* Error */
-.highlight .k { color: #66d9ef } /* Keyword */
-.highlight .l { color: #ae81ff } /* Literal */
-.highlight .n { color: #f8f8f2 } /* Name */
-.highlight .o { color: #f92672 } /* Operator */
-.highlight .p { color: #f8f8f2 } /* Punctuation */
-.highlight .ch { color: #75715e } /* Comment.Hashbang */
-.highlight .cm { color: #75715e } /* Comment.Multiline */
-.highlight .cp { color: #75715e } /* Comment.Preproc */
-.highlight .cpf { color: #75715e } /* Comment.PreprocFile */
-.highlight .c1 { color: #75715e } /* Comment.Single */
-.highlight .cs { color: #75715e } /* Comment.Special */
-.highlight .gd { color: #f92672 } /* Generic.Deleted */
-.highlight .ge { font-style: italic } /* Generic.Emph */
-.highlight .gi { color: #a6e22e } /* Generic.Inserted */
-.highlight .gs { font-weight: bold } /* Generic.Strong */
-.highlight .gu { color: #75715e } /* Generic.Subheading */
-.highlight .kc { color: #66d9ef } /* Keyword.Constant */
-.highlight .kd { color: #66d9ef } /* Keyword.Declaration */
-.highlight .kn { color: #f92672 } /* Keyword.Namespace */
-.highlight .kp { color: #66d9ef } /* Keyword.Pseudo */
-.highlight .kr { color: #66d9ef } /* Keyword.Reserved */
-.highlight .kt { color: #66d9ef } /* Keyword.Type */
-.highlight .ld { color: #e6db74 } /* Literal.Date */
-.highlight .m { color: #ae81ff } /* Literal.Number */
-.highlight .s { color: #e6db74 } /* Literal.String */
-.highlight .na { color: #a6e22e } /* Name.Attribute */
-.highlight .nb { color: #f8f8f2 } /* Name.Builtin */
-.highlight .nc { color: #a6e22e } /* Name.Class */
-.highlight .no { color: #66d9ef } /* Name.Constant */
-.highlight .nd { color: #a6e22e } /* Name.Decorator */
-.highlight .ni { color: #f8f8f2 } /* Name.Entity */
-.highlight .ne { color: #a6e22e } /* Name.Exception */
-.highlight .nf { color: #a6e22e } /* Name.Function */
-.highlight .nl { color: #f8f8f2 } /* Name.Label */
-.highlight .nn { color: #f8f8f2 } /* Name.Namespace */
-.highlight .nx { color: #a6e22e } /* Name.Other */
-.highlight .py { color: #f8f8f2 } /* Name.Property */
-.highlight .nt { color: #f92672 } /* Name.Tag */
-.highlight .nv { color: #f8f8f2 } /* Name.Variable */
-.highlight .ow { color: #f92672 } /* Operator.Word */
-.highlight .w { color: #f8f8f2 } /* Text.Whitespace */
-.highlight .mb { color: #ae81ff } /* Literal.Number.Bin */
-.highlight .mf { color: #ae81ff } /* Literal.Number.Float */
-.highlight .mh { color: #ae81ff } /* Literal.Number.Hex */
-.highlight .mi { color: #ae81ff } /* Literal.Number.Integer */
-.highlight .mo { color: #ae81ff } /* Literal.Number.Oct */
-.highlight .sa { color: #e6db74 } /* Literal.String.Affix */
-.highlight .sb { color: #e6db74 } /* Literal.String.Backtick */
-.highlight .sc { color: #e6db74 } /* Literal.String.Char */
-.highlight .dl { color: #e6db74 } /* Literal.String.Delimiter */
-.highlight .sd { color: #e6db74 } /* Literal.String.Doc */
-.highlight .s2 { color: #e6db74 } /* Literal.String.Double */
-.highlight .se { color: #ae81ff } /* Literal.String.Escape */
-.highlight .sh { color: #e6db74 } /* Literal.String.Heredoc */
-.highlight .si { color: #e6db74 } /* Literal.String.Interpol */
-.highlight .sx { color: #e6db74 } /* Literal.String.Other */
-.highlight .sr { color: #e6db74 } /* Literal.String.Regex */
-.highlight .s1 { color: #e6db74 } /* Literal.String.Single */
-.highlight .ss { color: #e6db74 } /* Literal.String.Symbol */
-.highlight .bp { color: #f8f8f2 } /* Name.Builtin.Pseudo */
-.highlight .fm { color: #a6e22e } /* Name.Function.Magic */
-.highlight .vc { color: #f8f8f2 } /* Name.Variable.Class */
-.highlight .vg { color: #f8f8f2 } /* Name.Variable.Global */
-.highlight .vi { color: #f8f8f2 } /* Name.Variable.Instance */
-.highlight .vm { color: #f8f8f2 } /* Name.Variable.Magic */
-.highlight .il { color: #ae81ff } /* Literal.Number.Integer.Long */
diff --git a/spaces/jessica6105/Lu-Bert-VITS2/mel_processing.py b/spaces/jessica6105/Lu-Bert-VITS2/mel_processing.py
deleted file mode 100644
index aab5bd926a194610b7ce3da29c553bd877341aa4..0000000000000000000000000000000000000000
--- a/spaces/jessica6105/Lu-Bert-VITS2/mel_processing.py
+++ /dev/null
@@ -1,139 +0,0 @@
-import torch
-import torch.utils.data
-from librosa.filters import mel as librosa_mel_fn
-
-MAX_WAV_VALUE = 32768.0
-
-
-def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
-    """
-    PARAMS
-    ------
-    C: compression factor
-    """
-    return torch.log(torch.clamp(x, min=clip_val) * C)
-
-
-def dynamic_range_decompression_torch(x, C=1):
-    """
-    PARAMS
-    ------
-    C: compression factor used to compress
-    """
-    return torch.exp(x) / C
-
-
-def spectral_normalize_torch(magnitudes):
-    output = dynamic_range_compression_torch(magnitudes)
-    return output
-
-
-def spectral_de_normalize_torch(magnitudes):
-    output = dynamic_range_decompression_torch(magnitudes)
-    return output
-
-
-mel_basis = {}
-hann_window = {}
-
-
-def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
-    if torch.min(y) < -1.0:
-        print("min value is ", torch.min(y))
-    if torch.max(y) > 1.0:
-        print("max value is ", torch.max(y))
-
-    global hann_window
-    dtype_device = str(y.dtype) + "_" + str(y.device)
-    wnsize_dtype_device = str(win_size) + "_" + dtype_device
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(
-            dtype=y.dtype, device=y.device
-        )
-
-    y = torch.nn.functional.pad(
-        y.unsqueeze(1),
-        (int((n_fft - hop_size) / 2), int((n_fft - hop_size) / 2)),
-        mode="reflect",
-    )
-    y = y.squeeze(1)
-
-    spec = torch.stft(
-        y,
-        n_fft,
-        hop_length=hop_size,
-        win_length=win_size,
-        window=hann_window[wnsize_dtype_device],
-        center=center,
-        pad_mode="reflect",
-        normalized=False,
-        onesided=True,
-        return_complex=False,
-    )
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-    return spec
-
-
-def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax):
-    global mel_basis
-    dtype_device = str(spec.dtype) + "_" + str(spec.device)
-    fmax_dtype_device = str(fmax) + "_" + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(
-            dtype=spec.dtype, device=spec.device
-        )
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-    return spec
-
-
-def mel_spectrogram_torch(
-    y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False
-):
-    if torch.min(y) < -1.0:
-        print("min value is ", torch.min(y))
-    if torch.max(y) > 1.0:
-        print("max value is ", torch.max(y))
-
-    global mel_basis, hann_window
-    dtype_device = str(y.dtype) + "_" + str(y.device)
-    fmax_dtype_device = str(fmax) + "_" + dtype_device
-    wnsize_dtype_device = str(win_size) + "_" + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(
-            dtype=y.dtype, device=y.device
-        )
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(
-            dtype=y.dtype, device=y.device
-        )
-
-    y = torch.nn.functional.pad(
-        y.unsqueeze(1),
-        (int((n_fft - hop_size) / 2), int((n_fft - hop_size) / 2)),
-        mode="reflect",
-    )
-    y = y.squeeze(1)
-
-    spec = torch.stft(
-        y,
-        n_fft,
-        hop_length=hop_size,
-        win_length=win_size,
-        window=hann_window[wnsize_dtype_device],
-        center=center,
-        pad_mode="reflect",
-        normalized=False,
-        onesided=True,
-        return_complex=False,
-    )
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-
-    return spec
diff --git a/spaces/joaogabriellima/Real-Time-Voice-Cloning/app.py b/spaces/joaogabriellima/Real-Time-Voice-Cloning/app.py
deleted file mode 100644
index 84df0269552db39f2b8f3efeeacf0eac26c4a06c..0000000000000000000000000000000000000000
--- a/spaces/joaogabriellima/Real-Time-Voice-Cloning/app.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import gradio as gr
-import os
-import shlex
-import gdown
-import uuid
-import torch
-
-cpu_param = "--cpu" if not torch.cuda.is_available() else ""
-
-if (not os.path.exists("synpretrained.pt")):
-    gdown.download("https://drive.google.com/u/0/uc?id=1EqFMIbvxffxtjiVrtykroF6_mUh-5Z3s&export=download&confirm=t",
-                   "synpretrained.pt", quiet=False)
-    gdown.download("https://drive.google.com/uc?export=download&id=1q8mEGwCkFy23KZsinbuvdKAQLqNKbYf1",
-                   "encpretrained.pt", quiet=False)
-    gdown.download("https://drive.google.com/uc?export=download&id=1cf2NO6FtI0jDuy8AV3Xgn6leO6dHjIgu",
-                   "vocpretrained.pt", quiet=False)
-
-
-def inference(audio_path, text, mic_path=None):
-    if mic_path:
-        audio_path = mic_path
-    output_path = f"/tmp/output_{uuid.uuid4()}.wav"
-    os.system(
-        f"python demo_cli.py --no_sound {cpu_param} --audio_path {audio_path} --text {shlex.quote(text.strip())} --output_path {output_path}")
-    return output_path
-
-
-title = "Real-Time-Voice-Cloning"
-description = "Gradio demo for Real-Time-Voice-Cloning: Clone a voice in 5 seconds to generate arbitrary speech in real-time. To use it, simply upload your audio, or click one of the examples to load them. Read more at the links below."
-article = "<p style='text-align: center'><a href='https://matheo.uliege.be/handle/2268.2/6801' target='_blank'>Real-Time Voice Cloning</a> | <a href='https://github.com/CorentinJ/Real-Time-Voice-Cloning' target='_blank'>Github Repo</a></p>"
-
-examples = [['test.wav', "This is real time voice cloning on huggingface spaces"]]
-
-
-def toggle(choice):
-    if choice == "mic":
-        return gr.update(visible=True, value=None), gr.update(visible=False, value=None)
-    else:
-        return gr.update(visible=False, value=None), gr.update(visible=True, value=None)
-
-
-with gr.Blocks() as demo:
-    with gr.Row():
-        with gr.Column():
-            radio = gr.Radio(["mic", "file"], value="mic",
-                             label="How would you like to upload your audio?")
-            mic_input = gr.Mic(label="Input", type="filepath", visible=False)
-            audio_file = gr.Audio(
-                type="filepath", label="Input", visible=True)
-            text_input = gr.Textbox(label="Text")
-        with gr.Column():
-            audio_output = gr.Audio(label="Output")
-
-    gr.Examples(examples, fn=inference, inputs=[audio_file, text_input],
-                      outputs=audio_output, cache_examples=True)
-    btn = gr.Button("Generate")
-    btn.click(inference, inputs=[audio_file,
-              text_input, mic_input], outputs=audio_output)
-    radio.change(toggle, radio, [mic_input, audio_file])
-
-demo.launch(enable_queue=True)
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/PyPDF2/papersizes.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/PyPDF2/papersizes.py
deleted file mode 100644
index 51aa2de597fc1521e7d5908ca0905e054da9fce2..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/PyPDF2/papersizes.py
+++ /dev/null
@@ -1,48 +0,0 @@
-"""Helper to get paper sizes."""
-
-from collections import namedtuple
-
-Dimensions = namedtuple("Dimensions", ["width", "height"])
-
-
-class PaperSize:
-    """(width, height) of the paper in portrait mode in pixels at 72 ppi."""
-
-    # Notes how to calculate it:
-    # 1. Get the size of the paper in mm
-    # 2. Convert it to inches (25.4 millimeters are equal to 1 inches)
-    # 3. Convert it to pixels ad 72dpi (1 inch is equal to 72 pixels)
-
-    # All Din-A paper sizes follow this pattern:
-    # 2xA(n-1) = A(n)
-    # So the height of the next bigger one is the width of the smaller one
-    # The ratio is always approximately the ratio 1:2**0.5
-    # Additionally, A0 is defined to have an area of 1 m**2
-    # Be aware of rounding issues!
-    A0 = Dimensions(2384, 3370)  # 841mm x 1189mm
-    A1 = Dimensions(1684, 2384)
-    A2 = Dimensions(1191, 1684)
-    A3 = Dimensions(842, 1191)
-    A4 = Dimensions(
-        595, 842
-    )  # Printer paper, documents - this is by far the most common
-    A5 = Dimensions(420, 595)  # Paperback books
-    A6 = Dimensions(298, 420)  # Post cards
-    A7 = Dimensions(210, 298)
-    A8 = Dimensions(147, 210)
-
-    # Envelopes
-    C4 = Dimensions(649, 918)
-
-
-_din_a = (
-    PaperSize.A0,
-    PaperSize.A1,
-    PaperSize.A2,
-    PaperSize.A3,
-    PaperSize.A4,
-    PaperSize.A5,
-    PaperSize.A6,
-    PaperSize.A7,
-    PaperSize.A8,
-)
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/async_timeout/__init__.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/async_timeout/__init__.py
deleted file mode 100644
index 1ffb069fce9b2b9a03515404155a7e5cc439484a..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/async_timeout/__init__.py
+++ /dev/null
@@ -1,239 +0,0 @@
-import asyncio
-import enum
-import sys
-import warnings
-from types import TracebackType
-from typing import Optional, Type
-
-
-if sys.version_info >= (3, 8):
-    from typing import final
-else:
-    from typing_extensions import final
-
-
-if sys.version_info >= (3, 11):
-
-    def _uncancel_task(task: "asyncio.Task[object]") -> None:
-        task.uncancel()
-
-else:
-
-    def _uncancel_task(task: "asyncio.Task[object]") -> None:
-        pass
-
-
-__version__ = "4.0.3"
-
-
-__all__ = ("timeout", "timeout_at", "Timeout")
-
-
-def timeout(delay: Optional[float]) -> "Timeout":
-    """timeout context manager.
-
-    Useful in cases when you want to apply timeout logic around block
-    of code or in cases when asyncio.wait_for is not suitable. For example:
-
-    >>> async with timeout(0.001):
-    ...     async with aiohttp.get('https://github.com') as r:
-    ...         await r.text()
-
-
-    delay - value in seconds or None to disable timeout logic
-    """
-    loop = asyncio.get_running_loop()
-    if delay is not None:
-        deadline = loop.time() + delay  # type: Optional[float]
-    else:
-        deadline = None
-    return Timeout(deadline, loop)
-
-
-def timeout_at(deadline: Optional[float]) -> "Timeout":
-    """Schedule the timeout at absolute time.
-
-    deadline argument points on the time in the same clock system
-    as loop.time().
-
-    Please note: it is not POSIX time but a time with
-    undefined starting base, e.g. the time of the system power on.
-
-    >>> async with timeout_at(loop.time() + 10):
-    ...     async with aiohttp.get('https://github.com') as r:
-    ...         await r.text()
-
-
-    """
-    loop = asyncio.get_running_loop()
-    return Timeout(deadline, loop)
-
-
-class _State(enum.Enum):
-    INIT = "INIT"
-    ENTER = "ENTER"
-    TIMEOUT = "TIMEOUT"
-    EXIT = "EXIT"
-
-
-@final
-class Timeout:
-    # Internal class, please don't instantiate it directly
-    # Use timeout() and timeout_at() public factories instead.
-    #
-    # Implementation note: `async with timeout()` is preferred
-    # over `with timeout()`.
-    # While technically the Timeout class implementation
-    # doesn't need to be async at all,
-    # the `async with` statement explicitly points that
-    # the context manager should be used from async function context.
-    #
-    # This design allows to avoid many silly misusages.
-    #
-    # TimeoutError is raised immediately when scheduled
-    # if the deadline is passed.
-    # The purpose is to time out as soon as possible
-    # without waiting for the next await expression.
-
-    __slots__ = ("_deadline", "_loop", "_state", "_timeout_handler", "_task")
-
-    def __init__(
-        self, deadline: Optional[float], loop: asyncio.AbstractEventLoop
-    ) -> None:
-        self._loop = loop
-        self._state = _State.INIT
-
-        self._task: Optional["asyncio.Task[object]"] = None
-        self._timeout_handler = None  # type: Optional[asyncio.Handle]
-        if deadline is None:
-            self._deadline = None  # type: Optional[float]
-        else:
-            self.update(deadline)
-
-    def __enter__(self) -> "Timeout":
-        warnings.warn(
-            "with timeout() is deprecated, use async with timeout() instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self._do_enter()
-        return self
-
-    def __exit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
-        self._do_exit(exc_type)
-        return None
-
-    async def __aenter__(self) -> "Timeout":
-        self._do_enter()
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
-        self._do_exit(exc_type)
-        return None
-
-    @property
-    def expired(self) -> bool:
-        """Is timeout expired during execution?"""
-        return self._state == _State.TIMEOUT
-
-    @property
-    def deadline(self) -> Optional[float]:
-        return self._deadline
-
-    def reject(self) -> None:
-        """Reject scheduled timeout if any."""
-        # cancel is maybe better name but
-        # task.cancel() raises CancelledError in asyncio world.
-        if self._state not in (_State.INIT, _State.ENTER):
-            raise RuntimeError(f"invalid state {self._state.value}")
-        self._reject()
-
-    def _reject(self) -> None:
-        self._task = None
-        if self._timeout_handler is not None:
-            self._timeout_handler.cancel()
-            self._timeout_handler = None
-
-    def shift(self, delay: float) -> None:
-        """Advance timeout on delay seconds.
-
-        The delay can be negative.
-
-        Raise RuntimeError if shift is called when deadline is not scheduled
-        """
-        deadline = self._deadline
-        if deadline is None:
-            raise RuntimeError("cannot shift timeout if deadline is not scheduled")
-        self.update(deadline + delay)
-
-    def update(self, deadline: float) -> None:
-        """Set deadline to absolute value.
-
-        deadline argument points on the time in the same clock system
-        as loop.time().
-
-        If new deadline is in the past the timeout is raised immediately.
-
-        Please note: it is not POSIX time but a time with
-        undefined starting base, e.g. the time of the system power on.
-        """
-        if self._state == _State.EXIT:
-            raise RuntimeError("cannot reschedule after exit from context manager")
-        if self._state == _State.TIMEOUT:
-            raise RuntimeError("cannot reschedule expired timeout")
-        if self._timeout_handler is not None:
-            self._timeout_handler.cancel()
-        self._deadline = deadline
-        if self._state != _State.INIT:
-            self._reschedule()
-
-    def _reschedule(self) -> None:
-        assert self._state == _State.ENTER
-        deadline = self._deadline
-        if deadline is None:
-            return
-
-        now = self._loop.time()
-        if self._timeout_handler is not None:
-            self._timeout_handler.cancel()
-
-        self._task = asyncio.current_task()
-        if deadline <= now:
-            self._timeout_handler = self._loop.call_soon(self._on_timeout)
-        else:
-            self._timeout_handler = self._loop.call_at(deadline, self._on_timeout)
-
-    def _do_enter(self) -> None:
-        if self._state != _State.INIT:
-            raise RuntimeError(f"invalid state {self._state.value}")
-        self._state = _State.ENTER
-        self._reschedule()
-
-    def _do_exit(self, exc_type: Optional[Type[BaseException]]) -> None:
-        if exc_type is asyncio.CancelledError and self._state == _State.TIMEOUT:
-            assert self._task is not None
-            _uncancel_task(self._task)
-            self._timeout_handler = None
-            self._task = None
-            raise asyncio.TimeoutError
-        # timeout has not expired
-        self._state = _State.EXIT
-        self._reject()
-        return None
-
-    def _on_timeout(self) -> None:
-        assert self._task is not None
-        self._task.cancel()
-        self._state = _State.TIMEOUT
-        # drop the reference early
-        self._timeout_handler = None
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/dns/rdtypes/ANY/CAA.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/dns/rdtypes/ANY/CAA.py
deleted file mode 100644
index 8afb538c0505b5468a6e376c6c76ae4c98744c6f..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/dns/rdtypes/ANY/CAA.py
+++ /dev/null
@@ -1,72 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-
-import dns.exception
-import dns.immutable
-import dns.rdata
-import dns.tokenizer
-
-
-@dns.immutable.immutable
-class CAA(dns.rdata.Rdata):
-
-    """CAA (Certification Authority Authorization) record"""
-
-    # see: RFC 6844
-
-    __slots__ = ["flags", "tag", "value"]
-
-    def __init__(self, rdclass, rdtype, flags, tag, value):
-        super().__init__(rdclass, rdtype)
-        self.flags = self._as_uint8(flags)
-        self.tag = self._as_bytes(tag, True, 255)
-        if not tag.isalnum():
-            raise ValueError("tag is not alphanumeric")
-        self.value = self._as_bytes(value)
-
-    def to_text(self, origin=None, relativize=True, **kw):
-        return '%u %s "%s"' % (
-            self.flags,
-            dns.rdata._escapify(self.tag),
-            dns.rdata._escapify(self.value),
-        )
-
-    @classmethod
-    def from_text(
-        cls, rdclass, rdtype, tok, origin=None, relativize=True, relativize_to=None
-    ):
-        flags = tok.get_uint8()
-        tag = tok.get_string().encode()
-        value = tok.get_string().encode()
-        return cls(rdclass, rdtype, flags, tag, value)
-
-    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
-        file.write(struct.pack("!B", self.flags))
-        l = len(self.tag)
-        assert l < 256
-        file.write(struct.pack("!B", l))
-        file.write(self.tag)
-        file.write(self.value)
-
-    @classmethod
-    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
-        flags = parser.get_uint8()
-        tag = parser.get_counted_bytes()
-        value = parser.get_remaining()
-        return cls(rdclass, rdtype, flags, tag, value)
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/ttLib/tables/T_S_I_J_.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/ttLib/tables/T_S_I_J_.py
deleted file mode 100644
index bc8fe92aac9d18bfd5ee565588d8cebf7d00afd1..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/ttLib/tables/T_S_I_J_.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from .T_S_I_V_ import table_T_S_I_V_
-
-
-class table_T_S_I_J_(table_T_S_I_V_):
-    pass
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/unicodedata/OTTags.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/unicodedata/OTTags.py
deleted file mode 100644
index 859a3bcdcf29bcdda827edad766ffeab2f0b636a..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/unicodedata/OTTags.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# Data updated to OpenType 1.8.2 as of January 2018.
-
-# Complete list of OpenType script tags at:
-# https://www.microsoft.com/typography/otspec/scripttags.htm
-
-# Most of the script tags are the same as the ISO 15924 tag but lowercased,
-# so we only have to handle the exceptional cases:
-# - KATAKANA and HIRAGANA both map to 'kana';
-# - spaces at the end are preserved, unlike ISO 15924;
-# - we map special script codes for Inherited, Common and Unknown to DFLT.
-
-DEFAULT_SCRIPT = "DFLT"
-
-SCRIPT_ALIASES = {
-    "jamo": "hang",
-}
-
-SCRIPT_EXCEPTIONS = {
-    "Hira": "kana",
-    "Hrkt": "kana",
-    "Laoo": "lao ",
-    "Yiii": "yi  ",
-    "Nkoo": "nko ",
-    "Vaii": "vai ",
-    "Zmth": "math",
-    "Zinh": DEFAULT_SCRIPT,
-    "Zyyy": DEFAULT_SCRIPT,
-    "Zzzz": DEFAULT_SCRIPT,
-}
-
-SCRIPT_EXCEPTIONS_REVERSED = {
-    "math": "Zmth",
-}
-
-NEW_SCRIPT_TAGS = {
-    "Beng": ("bng2",),
-    "Deva": ("dev2",),
-    "Gujr": ("gjr2",),
-    "Guru": ("gur2",),
-    "Knda": ("knd2",),
-    "Mlym": ("mlm2",),
-    "Orya": ("ory2",),
-    "Taml": ("tml2",),
-    "Telu": ("tel2",),
-    "Mymr": ("mym2",),
-}
-
-NEW_SCRIPT_TAGS_REVERSED = {
-    value: key for key, values in NEW_SCRIPT_TAGS.items() for value in values
-}
diff --git a/spaces/johnslegers/custom-diffusion/trainer.py b/spaces/johnslegers/custom-diffusion/trainer.py
deleted file mode 100644
index 3b15d11551c018d49d189566c74dd936f5bd49d8..0000000000000000000000000000000000000000
--- a/spaces/johnslegers/custom-diffusion/trainer.py
+++ /dev/null
@@ -1,164 +0,0 @@
-from __future__ import annotations
-
-import os
-import pathlib
-import shlex
-import shutil
-import subprocess
-
-import gradio as gr
-import PIL.Image
-import torch
-import json
-
-os.environ['PYTHONPATH'] = f'custom-diffusion:{os.getenv("PYTHONPATH", "")}'
-
-
-def pad_image(image: PIL.Image.Image) -> PIL.Image.Image:
-    w, h = image.size
-    if w == h:
-        return image
-    elif w > h:
-        new_image = PIL.Image.new(image.mode, (w, w), (0, 0, 0))
-        new_image.paste(image, (0, (w - h) // 2))
-        return new_image
-    else:
-        new_image = PIL.Image.new(image.mode, (h, h), (0, 0, 0))
-        new_image.paste(image, ((h - w) // 2, 0))
-        return new_image
-
-
-class Trainer:
-    def __init__(self):
-        self.is_running = False
-        self.is_running_message = 'Another training is in progress.'
-
-        self.output_dir = pathlib.Path('results')
-        self.instance_data_dir = self.output_dir / 'training_data'
-        self.class_data_dir = self.output_dir / 'regularization_data'
-
-    def check_if_running(self) -> dict:
-        if self.is_running:
-            return gr.update(value=self.is_running_message)
-        else:
-            return gr.update(value='No training is running.')
-
-    def cleanup_dirs(self) -> None:
-        shutil.rmtree(self.output_dir, ignore_errors=True)
-
-    def prepare_dataset(self, concept_images_collection: list, concept_prompt_collection: list, class_prompt_collection: list, resolution: int) -> None:
-        self.instance_data_dir.mkdir(parents=True)
-        concepts_list = []
-
-        for i in range(len(concept_images_collection)):
-            concept_dir =  self.instance_data_dir /  f'{i}'
-            class_dir = self.class_data_dir / f'{i}'
-            concept_dir.mkdir(parents=True)
-            concept_images = concept_images_collection[i]
-
-            concepts_list.append(
-                    {
-                        "instance_prompt": concept_prompt_collection[i],
-                        "class_prompt": class_prompt_collection[i],
-                        "instance_data_dir": f'{concept_dir}',
-                        "class_data_dir": f'{class_dir}'
-                    }
-                )
-
-            for i, temp_path in enumerate(concept_images):
-                image = PIL.Image.open(temp_path.name)
-                image = pad_image(image)
-                # image = image.resize((resolution, resolution))
-                image = image.convert('RGB')
-                out_path = concept_dir / f'{i:03d}.jpg'
-                image.save(out_path, format='JPEG', quality=100)
-
-        print(concepts_list)
-        json.dump(concepts_list, open( f'{self.output_dir}/temp.json' , 'w') )
-
-        
-    def run(
-        self,
-        base_model: str,
-        resolution_s: str,
-        n_steps: int,
-        learning_rate: float,
-        train_text_encoder: bool,
-        modifier_token: bool,
-        gradient_accumulation: int,
-        batch_size: int,
-        use_8bit_adam: bool,
-        gradient_checkpointing: bool,
-        gen_images: bool,
-        num_reg_images: int,
-        *inputs, 
-    ) -> tuple[dict, list[pathlib.Path]]:
-        if not torch.cuda.is_available():
-            raise gr.Error('CUDA is not available.')
-
-        num_concept = 0
-        for i in range(len(inputs) // 3):
-            if inputs[i] != None:
-                num_concept +=1
-
-        print(num_concept, inputs)
-        concept_images_collection = inputs[: num_concept]
-        concept_prompt_collection = inputs[3:  3 + num_concept]
-        class_prompt_collection = inputs[6: 6+num_concept]
-        if self.is_running:
-            return gr.update(value=self.is_running_message), []
-
-        if concept_images_collection is None:
-            raise gr.Error('You need to upload images.')
-        if not concept_prompt_collection:
-            raise gr.Error('The concept prompt is missing.')
-
-        resolution = int(resolution_s)
-
-        self.cleanup_dirs()
-        self.prepare_dataset(concept_images_collection, concept_prompt_collection, class_prompt_collection, resolution)
-        torch.cuda.empty_cache()
-        command = f'''
-        accelerate launch custom-diffusion/src/diffuser_training.py \
-          --pretrained_model_name_or_path={base_model}   \
-          --output_dir={self.output_dir} \
-          --concepts_list={f'{self.output_dir}/temp.json'} \
-          --with_prior_preservation --prior_loss_weight=1.0 \
-          --resolution={resolution}  \
-          --train_batch_size={batch_size}  \
-          --gradient_accumulation_steps={gradient_accumulation}  \
-          --learning_rate={learning_rate}  \
-          --lr_scheduler="constant" \
-          --lr_warmup_steps=0 \
-          --max_train_steps={n_steps} \
-          --num_class_images={num_reg_images} \
-          --initializer_token="ktn+pll+ucd" \
-          --scale_lr --hflip 
-        '''
-        if modifier_token:
-            tokens = '+'.join([f'<new{i+1}>' for i in range(num_concept)])
-            command += f' --modifier_token {tokens}'
-            
-        if not gen_images:
-            command += ' --real_prior'
-        if use_8bit_adam:
-            command += ' --use_8bit_adam'
-        if train_text_encoder:
-            command += f' --train_text_encoder'
-        if gradient_checkpointing:
-            command += f' --gradient_checkpointing'
-        
-        with open(self.output_dir / 'train.sh', 'w') as f:
-            command_s = ' '.join(command.split())
-            f.write(command_s)
-
-        self.is_running = True
-        res = subprocess.run(shlex.split(command))
-        self.is_running = False
-
-        if res.returncode == 0:
-            result_message = 'Training Completed!'
-        else:
-            result_message = 'Training Failed!'
-        weight_paths = sorted(self.output_dir.glob('*.bin'))
-        return gr.update(value=result_message), weight_paths
diff --git a/spaces/johnslegers/stable-diffusion-gui-test/README.md b/spaces/johnslegers/stable-diffusion-gui-test/README.md
deleted file mode 100644
index 2a235563c4180702de2d719e361362a6f0d850f0..0000000000000000000000000000000000000000
--- a/spaces/johnslegers/stable-diffusion-gui-test/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Stable Diffusion GUI test
-colorFrom: green
-colorTo: green
-sdk: gradio
-sdk_version: 3.1.7
-app_file: start.py
-datasets: [emotion]
-license: mit
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/joshen/gpt-academic/crazy_functions/test_project/cpp/longcode/jpge.cpp b/spaces/joshen/gpt-academic/crazy_functions/test_project/cpp/longcode/jpge.cpp
deleted file mode 100644
index 2e26b71ed5aad0d46478fdbcd3a880be1401f946..0000000000000000000000000000000000000000
--- a/spaces/joshen/gpt-academic/crazy_functions/test_project/cpp/longcode/jpge.cpp
+++ /dev/null
@@ -1,1049 +0,0 @@
-// jpge.cpp - C++ class for JPEG compression.
-// Public domain, Rich Geldreich <richgel99@gmail.com>
-// v1.01, Dec. 18, 2010 - Initial release
-// v1.02, Apr. 6, 2011 - Removed 2x2 ordered dither in H2V1 chroma subsampling method load_block_16_8_8(). (The rounding factor was 2, when it should have been 1. Either way, it wasn't helping.)
-// v1.03, Apr. 16, 2011 - Added support for optimized Huffman code tables, optimized dynamic memory allocation down to only 1 alloc.
-//                        Also from Alex Evans: Added RGBA support, linear memory allocator (no longer needed in v1.03).
-// v1.04, May. 19, 2012: Forgot to set m_pFile ptr to NULL in cfile_stream::close(). Thanks to Owen Kaluza for reporting this bug.
-//                       Code tweaks to fix VS2008 static code analysis warnings (all looked harmless).
-//                       Code review revealed method load_block_16_8_8() (used for the non-default H2V1 sampling mode to downsample chroma) somehow didn't get the rounding factor fix from v1.02.
-
-#include "jpge.h"
-
-#include <stdlib.h>
-#include <string.h>
-#if PLATFORM_WINDOWS
-#include <malloc.h>
-#endif
-
-#define JPGE_MAX(a,b) (((a)>(b))?(a):(b))
-#define JPGE_MIN(a,b) (((a)<(b))?(a):(b))
-
-namespace jpge {
-
-static inline void *jpge_malloc(size_t nSize) { return FMemory::Malloc(nSize); }
-static inline void jpge_free(void *p) { FMemory::Free(p);; }
-
-// Various JPEG enums and tables.
-enum { M_SOF0 = 0xC0, M_DHT = 0xC4, M_SOI = 0xD8, M_EOI = 0xD9, M_SOS = 0xDA, M_DQT = 0xDB, M_APP0 = 0xE0 };
-enum { DC_LUM_CODES = 12, AC_LUM_CODES = 256, DC_CHROMA_CODES = 12, AC_CHROMA_CODES = 256, MAX_HUFF_SYMBOLS = 257, MAX_HUFF_CODESIZE = 32 };
-
-static uint8 s_zag[64] = { 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63 };
-static int16 s_std_lum_quant[64] = { 16,11,12,14,12,10,16,14,13,14,18,17,16,19,24,40,26,24,22,22,24,49,35,37,29,40,58,51,61,60,57,51,56,55,64,72,92,78,64,68,87,69,55,56,80,109,81,87,95,98,103,104,103,62,77,113,121,112,100,120,92,101,103,99 };
-static int16 s_std_croma_quant[64] = { 17,18,18,24,21,24,47,26,26,47,99,66,56,66,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99 };
-static uint8 s_dc_lum_bits[17] = { 0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0 };
-static uint8 s_dc_lum_val[DC_LUM_CODES] = { 0,1,2,3,4,5,6,7,8,9,10,11 };
-static uint8 s_ac_lum_bits[17] = { 0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d };
-static uint8 s_ac_lum_val[AC_LUM_CODES]  =
-{
-  0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,
-  0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,
-  0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
-  0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,
-  0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
-  0xf9,0xfa
-};
-static uint8 s_dc_chroma_bits[17] = { 0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0 };
-static uint8 s_dc_chroma_val[DC_CHROMA_CODES]  = { 0,1,2,3,4,5,6,7,8,9,10,11 };
-static uint8 s_ac_chroma_bits[17] = { 0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77 };
-static uint8 s_ac_chroma_val[AC_CHROMA_CODES] =
-{
-  0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,
-  0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,
-  0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
-  0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,
-  0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
-  0xf9,0xfa
-};
-
-// Low-level helper functions.
-template <class T> inline void clear_obj(T &obj) { memset(&obj, 0, sizeof(obj)); }
-
-const int YR = 19595, YG = 38470, YB = 7471, CB_R = -11059, CB_G = -21709, CB_B = 32768, CR_R = 32768, CR_G = -27439, CR_B = -5329;
-static inline uint8 clamp(int i) { if (static_cast<uint>(i) > 255U) { if (i < 0) i = 0; else if (i > 255) i = 255; } return static_cast<uint8>(i); }
-
-static void RGB_to_YCC(uint8* pDst, const uint8 *pSrc, int num_pixels)
-{
-  for ( ; num_pixels; pDst += 3, pSrc += 3, num_pixels--)
-  {
-    const int r = pSrc[0], g = pSrc[1], b = pSrc[2];
-    pDst[0] = static_cast<uint8>((r * YR + g * YG + b * YB + 32768) >> 16);
-    pDst[1] = clamp(128 + ((r * CB_R + g * CB_G + b * CB_B + 32768) >> 16));
-    pDst[2] = clamp(128 + ((r * CR_R + g * CR_G + b * CR_B + 32768) >> 16));
-  }
-}
-
-static void RGB_to_Y(uint8* pDst, const uint8 *pSrc, int num_pixels)
-{
-  for ( ; num_pixels; pDst++, pSrc += 3, num_pixels--)
-    pDst[0] = static_cast<uint8>((pSrc[0] * YR + pSrc[1] * YG + pSrc[2] * YB + 32768) >> 16);
-}
-
-static void RGBA_to_YCC(uint8* pDst, const uint8 *pSrc, int num_pixels)
-{
-  for ( ; num_pixels; pDst += 3, pSrc += 4, num_pixels--)
-  {
-    const int r = pSrc[0], g = pSrc[1], b = pSrc[2];
-    pDst[0] = static_cast<uint8>((r * YR + g * YG + b * YB + 32768) >> 16);
-    pDst[1] = clamp(128 + ((r * CB_R + g * CB_G + b * CB_B + 32768) >> 16));
-    pDst[2] = clamp(128 + ((r * CR_R + g * CR_G + b * CR_B + 32768) >> 16));
-  }
-}
-
-static void RGBA_to_Y(uint8* pDst, const uint8 *pSrc, int num_pixels)
-{
-  for ( ; num_pixels; pDst++, pSrc += 4, num_pixels--)
-    pDst[0] = static_cast<uint8>((pSrc[0] * YR + pSrc[1] * YG + pSrc[2] * YB + 32768) >> 16);
-}
-
-static void Y_to_YCC(uint8* pDst, const uint8* pSrc, int num_pixels)
-{
-  for( ; num_pixels; pDst += 3, pSrc++, num_pixels--) { pDst[0] = pSrc[0]; pDst[1] = 128; pDst[2] = 128; }
-}
-
-// Forward DCT - DCT derived from jfdctint.
-#define CONST_BITS  13
-#define ROW_BITS    2
-#define DCT_DESCALE(x, n) (((x) + (((int32)1) << ((n) - 1))) >> (n))
-#define DCT_MUL(var, c) (static_cast<int16>(var) * static_cast<int32>(c))
-#define DCT1D(s0, s1, s2, s3, s4, s5, s6, s7) \
-  int32 t0 = s0 + s7, t7 = s0 - s7, t1 = s1 + s6, t6 = s1 - s6, t2 = s2 + s5, t5 = s2 - s5, t3 = s3 + s4, t4 = s3 - s4; \
-  int32 t10 = t0 + t3, t13 = t0 - t3, t11 = t1 + t2, t12 = t1 - t2; \
-  int32 u1 = DCT_MUL(t12 + t13, 4433); \
-  s2 = u1 + DCT_MUL(t13, 6270); \
-  s6 = u1 + DCT_MUL(t12, -15137); \
-  u1 = t4 + t7; \
-  int32 u2 = t5 + t6, u3 = t4 + t6, u4 = t5 + t7; \
-  int32 z5 = DCT_MUL(u3 + u4, 9633); \
-  t4 = DCT_MUL(t4, 2446); t5 = DCT_MUL(t5, 16819); \
-  t6 = DCT_MUL(t6, 25172); t7 = DCT_MUL(t7, 12299); \
-  u1 = DCT_MUL(u1, -7373); u2 = DCT_MUL(u2, -20995); \
-  u3 = DCT_MUL(u3, -16069); u4 = DCT_MUL(u4, -3196); \
-  u3 += z5; u4 += z5; \
-  s0 = t10 + t11; s1 = t7 + u1 + u4; s3 = t6 + u2 + u3; s4 = t10 - t11; s5 = t5 + u2 + u4; s7 = t4 + u1 + u3;
-
-static void DCT2D(int32 *p)
-{
-  int32 c, *q = p;
-  for (c = 7; c >= 0; c--, q += 8)
-  {
-    int32 s0 = q[0], s1 = q[1], s2 = q[2], s3 = q[3], s4 = q[4], s5 = q[5], s6 = q[6], s7 = q[7];
-    DCT1D(s0, s1, s2, s3, s4, s5, s6, s7);
-    q[0] = s0 << ROW_BITS; q[1] = DCT_DESCALE(s1, CONST_BITS-ROW_BITS); q[2] = DCT_DESCALE(s2, CONST_BITS-ROW_BITS); q[3] = DCT_DESCALE(s3, CONST_BITS-ROW_BITS);
-    q[4] = s4 << ROW_BITS; q[5] = DCT_DESCALE(s5, CONST_BITS-ROW_BITS); q[6] = DCT_DESCALE(s6, CONST_BITS-ROW_BITS); q[7] = DCT_DESCALE(s7, CONST_BITS-ROW_BITS);
-  }
-  for (q = p, c = 7; c >= 0; c--, q++)
-  {
-    int32 s0 = q[0*8], s1 = q[1*8], s2 = q[2*8], s3 = q[3*8], s4 = q[4*8], s5 = q[5*8], s6 = q[6*8], s7 = q[7*8];
-    DCT1D(s0, s1, s2, s3, s4, s5, s6, s7);
-    q[0*8] = DCT_DESCALE(s0, ROW_BITS+3); q[1*8] = DCT_DESCALE(s1, CONST_BITS+ROW_BITS+3); q[2*8] = DCT_DESCALE(s2, CONST_BITS+ROW_BITS+3); q[3*8] = DCT_DESCALE(s3, CONST_BITS+ROW_BITS+3);
-    q[4*8] = DCT_DESCALE(s4, ROW_BITS+3); q[5*8] = DCT_DESCALE(s5, CONST_BITS+ROW_BITS+3); q[6*8] = DCT_DESCALE(s6, CONST_BITS+ROW_BITS+3); q[7*8] = DCT_DESCALE(s7, CONST_BITS+ROW_BITS+3);
-  }
-}
-
-struct sym_freq { uint m_key, m_sym_index; };
-
-// Radix sorts sym_freq[] array by 32-bit key m_key. Returns ptr to sorted values.
-static inline sym_freq* radix_sort_syms(uint num_syms, sym_freq* pSyms0, sym_freq* pSyms1)
-{
-  const uint cMaxPasses = 4;
-  uint32 hist[256 * cMaxPasses]; clear_obj(hist);
-  for (uint i = 0; i < num_syms; i++) { uint freq = pSyms0[i].m_key; hist[freq & 0xFF]++; hist[256 + ((freq >> 8) & 0xFF)]++; hist[256*2 + ((freq >> 16) & 0xFF)]++; hist[256*3 + ((freq >> 24) & 0xFF)]++; }
-  sym_freq* pCur_syms = pSyms0, *pNew_syms = pSyms1;
-  uint total_passes = cMaxPasses; while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) total_passes--;
-  for (uint pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8)
-  {
-    const uint32* pHist = &hist[pass << 8];
-    uint offsets[256], cur_ofs = 0;
-    for (uint i = 0; i < 256; i++) { offsets[i] = cur_ofs; cur_ofs += pHist[i]; }
-    for (uint i = 0; i < num_syms; i++)
-      pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i];
-    sym_freq* t = pCur_syms; pCur_syms = pNew_syms; pNew_syms = t;
-  }
-  return pCur_syms;
-}
-
-// calculate_minimum_redundancy() originally written by: Alistair Moffat, alistair@cs.mu.oz.au, Jyrki Katajainen, jyrki@diku.dk, November 1996.
-static void calculate_minimum_redundancy(sym_freq *A, int n)
-{
-  int root, leaf, next, avbl, used, dpth;
-  if (n==0) return; else if (n==1) { A[0].m_key = 1; return; }
-  A[0].m_key += A[1].m_key; root = 0; leaf = 2;
-  for (next=1; next < n-1; next++)
-  {
-    if (leaf>=n || A[root].m_key<A[leaf].m_key) { A[next].m_key = A[root].m_key; A[root++].m_key = next; } else A[next].m_key = A[leaf++].m_key;
-    if (leaf>=n || (root<next && A[root].m_key<A[leaf].m_key)) { A[next].m_key += A[root].m_key; A[root++].m_key = next; } else A[next].m_key += A[leaf++].m_key;
-  }
-  A[n-2].m_key = 0;
-  for (next=n-3; next>=0; next--) A[next].m_key = A[A[next].m_key].m_key+1;
-  avbl = 1; used = dpth = 0; root = n-2; next = n-1;
-  while (avbl>0)
-  {
-    while (root>=0 && (int)A[root].m_key==dpth) { used++; root--; }
-    while (avbl>used) { A[next--].m_key = dpth; avbl--; }
-    avbl = 2*used; dpth++; used = 0;
-  }
-}
-
-// Limits canonical Huffman code table's max code size to max_code_size.
-static void huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)
-{
-  if (code_list_len <= 1) return;
-
-  for (int i = max_code_size + 1; i <= MAX_HUFF_CODESIZE; i++) pNum_codes[max_code_size] += pNum_codes[i];
-
-  uint32 total = 0;
-  for (int i = max_code_size; i > 0; i--)
-    total += (((uint32)pNum_codes[i]) << (max_code_size - i));
-
-  while (total != (1UL << max_code_size))
-  {
-    pNum_codes[max_code_size]--;
-    for (int i = max_code_size - 1; i > 0; i--)
-    {
-      if (pNum_codes[i]) { pNum_codes[i]--; pNum_codes[i + 1] += 2; break; }
-    }
-    total--;
-  }
-}
-
-// Generates an optimized offman table.
-void jpeg_encoder::optimize_huffman_table(int table_num, int table_len)
-{
-  sym_freq syms0[MAX_HUFF_SYMBOLS], syms1[MAX_HUFF_SYMBOLS];
-  syms0[0].m_key = 1; syms0[0].m_sym_index = 0;  // dummy symbol, assures that no valid code contains all 1's
-  int num_used_syms = 1;
-  const uint32 *pSym_count = &m_huff_count[table_num][0];
-  for (int i = 0; i < table_len; i++)
-    if (pSym_count[i]) { syms0[num_used_syms].m_key = pSym_count[i]; syms0[num_used_syms++].m_sym_index = i + 1; }
-  sym_freq* pSyms = radix_sort_syms(num_used_syms, syms0, syms1);
-  calculate_minimum_redundancy(pSyms, num_used_syms);
-
-  // Count the # of symbols of each code size.
-  int num_codes[1 + MAX_HUFF_CODESIZE]; clear_obj(num_codes);
-  for (int i = 0; i < num_used_syms; i++)
-    num_codes[pSyms[i].m_key]++;
-
-  const uint JPGE_CODE_SIZE_LIMIT = 16; // the maximum possible size of a JPEG Huffman code (valid range is [9,16] - 9 vs. 8 because of the dummy symbol)
-  huffman_enforce_max_code_size(num_codes, num_used_syms, JPGE_CODE_SIZE_LIMIT);
-
-  // Compute m_huff_bits array, which contains the # of symbols per code size.
-  clear_obj(m_huff_bits[table_num]);
-  for (int i = 1; i <= (int)JPGE_CODE_SIZE_LIMIT; i++)
-    m_huff_bits[table_num][i] = static_cast<uint8>(num_codes[i]);
-
-  // Remove the dummy symbol added above, which must be in largest bucket.
-  for (int i = JPGE_CODE_SIZE_LIMIT; i >= 1; i--)
-  {
-    if (m_huff_bits[table_num][i]) { m_huff_bits[table_num][i]--; break; }
-  }
-
-  // Compute the m_huff_val array, which contains the symbol indices sorted by code size (smallest to largest).
-  for (int i = num_used_syms - 1; i >= 1; i--)
-    m_huff_val[table_num][num_used_syms - 1 - i] = static_cast<uint8>(pSyms[i].m_sym_index - 1);
-}
-
-// JPEG marker generation.
-void jpeg_encoder::emit_byte(uint8 i)
-{
-  m_all_stream_writes_succeeded = m_all_stream_writes_succeeded && m_pStream->put_obj(i);
-}
-
-void jpeg_encoder::emit_word(uint i)
-{
-  emit_byte(uint8(i >> 8)); emit_byte(uint8(i & 0xFF));
-}
-
-void jpeg_encoder::emit_marker(int marker)
-{
-  emit_byte(uint8(0xFF)); emit_byte(uint8(marker));
-}
-
-// Emit JFIF marker
-void jpeg_encoder::emit_jfif_app0()
-{
-  emit_marker(M_APP0);
-  emit_word(2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1);
-  emit_byte(0x4A); emit_byte(0x46); emit_byte(0x49); emit_byte(0x46); /* Identifier: ASCII "JFIF" */
-  emit_byte(0);
-  emit_byte(1);      /* Major version */
-  emit_byte(1);      /* Minor version */
-  emit_byte(0);      /* Density unit */
-  emit_word(1);
-  emit_word(1);
-  emit_byte(0);      /* No thumbnail image */
-  emit_byte(0);
-}
-
-// Emit quantization tables
-void jpeg_encoder::emit_dqt()
-{
-  for (int i = 0; i < ((m_num_components == 3) ? 2 : 1); i++)
-  {
-    emit_marker(M_DQT);
-    emit_word(64 + 1 + 2);
-    emit_byte(static_cast<uint8>(i));
-    for (int j = 0; j < 64; j++)
-      emit_byte(static_cast<uint8>(m_quantization_tables[i][j]));
-  }
-}
-
-// Emit start of frame marker
-void jpeg_encoder::emit_sof()
-{
-  emit_marker(M_SOF0);                           /* baseline */
-  emit_word(3 * m_num_components + 2 + 5 + 1);
-  emit_byte(8);                                  /* precision */
-  emit_word(m_image_y);
-  emit_word(m_image_x);
-  emit_byte(m_num_components);
-  for (int i = 0; i < m_num_components; i++)
-  {
-    emit_byte(static_cast<uint8>(i + 1));                                   /* component ID     */
-    emit_byte((m_comp_h_samp[i] << 4) + m_comp_v_samp[i]);  /* h and v sampling */
-    emit_byte(i > 0);                                   /* quant. table num */
-  }
-}
-
-// Emit Huffman table.
-void jpeg_encoder::emit_dht(uint8 *bits, uint8 *val, int index, bool ac_flag)
-{
-  emit_marker(M_DHT);
-
-  int length = 0;
-  for (int i = 1; i <= 16; i++)
-    length += bits[i];
-
-  emit_word(length + 2 + 1 + 16);
-  emit_byte(static_cast<uint8>(index + (ac_flag << 4)));
-
-  for (int i = 1; i <= 16; i++)
-    emit_byte(bits[i]);
-
-  for (int i = 0; i < length; i++)
-    emit_byte(val[i]);
-}
-
-// Emit all Huffman tables.
-void jpeg_encoder::emit_dhts()
-{
-  emit_dht(m_huff_bits[0+0], m_huff_val[0+0], 0, false);
-  emit_dht(m_huff_bits[2+0], m_huff_val[2+0], 0, true);
-  if (m_num_components == 3)
-  {
-    emit_dht(m_huff_bits[0+1], m_huff_val[0+1], 1, false);
-    emit_dht(m_huff_bits[2+1], m_huff_val[2+1], 1, true);
-  }
-}
-
-// emit start of scan
-void jpeg_encoder::emit_sos()
-{
-  emit_marker(M_SOS);
-  emit_word(2 * m_num_components + 2 + 1 + 3);
-  emit_byte(m_num_components);
-  for (int i = 0; i < m_num_components; i++)
-  {
-    emit_byte(static_cast<uint8>(i + 1));
-    if (i == 0)
-      emit_byte((0 << 4) + 0);
-    else
-      emit_byte((1 << 4) + 1);
-  }
-  emit_byte(0);     /* spectral selection */
-  emit_byte(63);
-  emit_byte(0);
-}
-
-// Emit all markers at beginning of image file.
-void jpeg_encoder::emit_markers()
-{
-  emit_marker(M_SOI);
-  emit_jfif_app0();
-  emit_dqt();
-  emit_sof();
-  emit_dhts();
-  emit_sos();
-}
-
-// Compute the actual canonical Huffman codes/code sizes given the JPEG huff bits and val arrays.
-void jpeg_encoder::compute_huffman_table(uint *codes, uint8 *code_sizes, uint8 *bits, uint8 *val)
-{
-  int i, l, last_p, si;
-  uint8 huff_size[257];
-  uint huff_code[257];
-  uint code;
-
-  int p = 0;
-  for (l = 1; l <= 16; l++)
-    for (i = 1; i <= bits[l]; i++)
-      huff_size[p++] = (char)l;
-
-  huff_size[p] = 0; last_p = p; // write sentinel
-
-  code = 0; si = huff_size[0]; p = 0;
-
-  while (huff_size[p])
-  {
-    while (huff_size[p] == si)
-      huff_code[p++] = code++;
-    code <<= 1;
-    si++;
-  }
-
-  memset(codes, 0, sizeof(codes[0])*256);
-  memset(code_sizes, 0, sizeof(code_sizes[0])*256);
-  for (p = 0; p < last_p; p++)
-  {
-    codes[val[p]]      = huff_code[p];
-    code_sizes[val[p]] = huff_size[p];
-  }
-}
-
-// Quantization table generation.
-void jpeg_encoder::compute_quant_table(int32 *pDst, int16 *pSrc)
-{
-  int32 q;
-  if (m_params.m_quality < 50)
-    q = 5000 / m_params.m_quality;
-  else
-    q = 200 - m_params.m_quality * 2;
-  for (int i = 0; i < 64; i++)
-  {
-    int32 j = *pSrc++; j = (j * q + 50L) / 100L;
-    *pDst++ = JPGE_MIN(JPGE_MAX(j, 1), 255);
-  }
-}
-
-// Higher-level methods.
-void jpeg_encoder::first_pass_init()
-{
-  m_bit_buffer = 0; m_bits_in = 0;
-  memset(m_last_dc_val, 0, 3 * sizeof(m_last_dc_val[0]));
-  m_mcu_y_ofs = 0;
-  m_pass_num = 1;
-}
-
-bool jpeg_encoder::second_pass_init()
-{
-  compute_huffman_table(&m_huff_codes[0+0][0], &m_huff_code_sizes[0+0][0], m_huff_bits[0+0], m_huff_val[0+0]);
-  compute_huffman_table(&m_huff_codes[2+0][0], &m_huff_code_sizes[2+0][0], m_huff_bits[2+0], m_huff_val[2+0]);
-  if (m_num_components > 1)
-  {
-    compute_huffman_table(&m_huff_codes[0+1][0], &m_huff_code_sizes[0+1][0], m_huff_bits[0+1], m_huff_val[0+1]);
-    compute_huffman_table(&m_huff_codes[2+1][0], &m_huff_code_sizes[2+1][0], m_huff_bits[2+1], m_huff_val[2+1]);
-  }
-  first_pass_init();
-  emit_markers();
-  m_pass_num = 2;
-  return true;
-}
-
-bool jpeg_encoder::jpg_open(int p_x_res, int p_y_res, int src_channels)
-{
-  m_num_components = 3;
-  switch (m_params.m_subsampling)
-  {
-    case Y_ONLY:
-    {
-      m_num_components = 1;
-      m_comp_h_samp[0] = 1; m_comp_v_samp[0] = 1;
-      m_mcu_x          = 8; m_mcu_y          = 8;
-      break;
-    }
-    case H1V1:
-    {
-      m_comp_h_samp[0] = 1; m_comp_v_samp[0] = 1;
-      m_comp_h_samp[1] = 1; m_comp_v_samp[1] = 1;
-      m_comp_h_samp[2] = 1; m_comp_v_samp[2] = 1;
-      m_mcu_x          = 8; m_mcu_y          = 8;
-      break;
-    }
-    case H2V1:
-    {
-      m_comp_h_samp[0] = 2; m_comp_v_samp[0] = 1;
-      m_comp_h_samp[1] = 1; m_comp_v_samp[1] = 1;
-      m_comp_h_samp[2] = 1; m_comp_v_samp[2] = 1;
-      m_mcu_x          = 16; m_mcu_y         = 8;
-      break;
-    }
-    case H2V2:
-    {
-      m_comp_h_samp[0] = 2; m_comp_v_samp[0] = 2;
-      m_comp_h_samp[1] = 1; m_comp_v_samp[1] = 1;
-      m_comp_h_samp[2] = 1; m_comp_v_samp[2] = 1;
-      m_mcu_x          = 16; m_mcu_y         = 16;
-    }
-  }
-
-  m_image_x        = p_x_res; m_image_y = p_y_res;
-  m_image_bpp      = src_channels;
-  m_image_bpl      = m_image_x * src_channels;
-  m_image_x_mcu    = (m_image_x + m_mcu_x - 1) & (~(m_mcu_x - 1));
-  m_image_y_mcu    = (m_image_y + m_mcu_y - 1) & (~(m_mcu_y - 1));
-  m_image_bpl_xlt  = m_image_x * m_num_components;
-  m_image_bpl_mcu  = m_image_x_mcu * m_num_components;
-  m_mcus_per_row   = m_image_x_mcu / m_mcu_x;
-
-  if ((m_mcu_lines[0] = static_cast<uint8*>(jpge_malloc(m_image_bpl_mcu * m_mcu_y))) == NULL) return false;
-  for (int i = 1; i < m_mcu_y; i++)
-    m_mcu_lines[i] = m_mcu_lines[i-1] + m_image_bpl_mcu;
-
-  compute_quant_table(m_quantization_tables[0], s_std_lum_quant);
-  compute_quant_table(m_quantization_tables[1], m_params.m_no_chroma_discrim_flag ? s_std_lum_quant : s_std_croma_quant);
-
-  m_out_buf_left = JPGE_OUT_BUF_SIZE;
-  m_pOut_buf = m_out_buf;
-
-  if (m_params.m_two_pass_flag)
-  {
-    clear_obj(m_huff_count);
-    first_pass_init();
-  }
-  else
-  {
-    memcpy(m_huff_bits[0+0], s_dc_lum_bits, 17);    memcpy(m_huff_val [0+0], s_dc_lum_val, DC_LUM_CODES);
-    memcpy(m_huff_bits[2+0], s_ac_lum_bits, 17);    memcpy(m_huff_val [2+0], s_ac_lum_val, AC_LUM_CODES);
-    memcpy(m_huff_bits[0+1], s_dc_chroma_bits, 17); memcpy(m_huff_val [0+1], s_dc_chroma_val, DC_CHROMA_CODES);
-    memcpy(m_huff_bits[2+1], s_ac_chroma_bits, 17); memcpy(m_huff_val [2+1], s_ac_chroma_val, AC_CHROMA_CODES);
-    if (!second_pass_init()) return false;   // in effect, skip over the first pass
-  }
-  return m_all_stream_writes_succeeded;
-}
-
-void jpeg_encoder::load_block_8_8_grey(int x)
-{
-  uint8 *pSrc;
-  sample_array_t *pDst = m_sample_array;
-  x <<= 3;
-  for (int i = 0; i < 8; i++, pDst += 8)
-  {
-    pSrc = m_mcu_lines[i] + x;
-    pDst[0] = pSrc[0] - 128; pDst[1] = pSrc[1] - 128; pDst[2] = pSrc[2] - 128; pDst[3] = pSrc[3] - 128;
-    pDst[4] = pSrc[4] - 128; pDst[5] = pSrc[5] - 128; pDst[6] = pSrc[6] - 128; pDst[7] = pSrc[7] - 128;
-  }
-}
-
-void jpeg_encoder::load_block_8_8(int x, int y, int c)
-{
-  uint8 *pSrc;
-  sample_array_t *pDst = m_sample_array;
-  x = (x * (8 * 3)) + c;
-  y <<= 3;
-  for (int i = 0; i < 8; i++, pDst += 8)
-  {
-    pSrc = m_mcu_lines[y + i] + x;
-    pDst[0] = pSrc[0 * 3] - 128; pDst[1] = pSrc[1 * 3] - 128; pDst[2] = pSrc[2 * 3] - 128; pDst[3] = pSrc[3 * 3] - 128;
-    pDst[4] = pSrc[4 * 3] - 128; pDst[5] = pSrc[5 * 3] - 128; pDst[6] = pSrc[6 * 3] - 128; pDst[7] = pSrc[7 * 3] - 128;
-  }
-}
-
-void jpeg_encoder::load_block_16_8(int x, int c)
-{
-  uint8 *pSrc1, *pSrc2;
-  sample_array_t *pDst = m_sample_array;
-  x = (x * (16 * 3)) + c;
-  int a = 0, b = 2;
-  for (int i = 0; i < 16; i += 2, pDst += 8)
-  {
-    pSrc1 = m_mcu_lines[i + 0] + x;
-    pSrc2 = m_mcu_lines[i + 1] + x;
-    pDst[0] = ((pSrc1[ 0 * 3] + pSrc1[ 1 * 3] + pSrc2[ 0 * 3] + pSrc2[ 1 * 3] + a) >> 2) - 128; pDst[1] = ((pSrc1[ 2 * 3] + pSrc1[ 3 * 3] + pSrc2[ 2 * 3] + pSrc2[ 3 * 3] + b) >> 2) - 128;
-    pDst[2] = ((pSrc1[ 4 * 3] + pSrc1[ 5 * 3] + pSrc2[ 4 * 3] + pSrc2[ 5 * 3] + a) >> 2) - 128; pDst[3] = ((pSrc1[ 6 * 3] + pSrc1[ 7 * 3] + pSrc2[ 6 * 3] + pSrc2[ 7 * 3] + b) >> 2) - 128;
-    pDst[4] = ((pSrc1[ 8 * 3] + pSrc1[ 9 * 3] + pSrc2[ 8 * 3] + pSrc2[ 9 * 3] + a) >> 2) - 128; pDst[5] = ((pSrc1[10 * 3] + pSrc1[11 * 3] + pSrc2[10 * 3] + pSrc2[11 * 3] + b) >> 2) - 128;
-    pDst[6] = ((pSrc1[12 * 3] + pSrc1[13 * 3] + pSrc2[12 * 3] + pSrc2[13 * 3] + a) >> 2) - 128; pDst[7] = ((pSrc1[14 * 3] + pSrc1[15 * 3] + pSrc2[14 * 3] + pSrc2[15 * 3] + b) >> 2) - 128;
-    int temp = a; a = b; b = temp;
-  }
-}
-
-void jpeg_encoder::load_block_16_8_8(int x, int c)
-{
-  uint8 *pSrc1;
-  sample_array_t *pDst = m_sample_array;
-  x = (x * (16 * 3)) + c;
-  for (int i = 0; i < 8; i++, pDst += 8)
-  {
-    pSrc1 = m_mcu_lines[i + 0] + x;
-    pDst[0] = ((pSrc1[ 0 * 3] + pSrc1[ 1 * 3]) >> 1) - 128; pDst[1] = ((pSrc1[ 2 * 3] + pSrc1[ 3 * 3]) >> 1) - 128;
-    pDst[2] = ((pSrc1[ 4 * 3] + pSrc1[ 5 * 3]) >> 1) - 128; pDst[3] = ((pSrc1[ 6 * 3] + pSrc1[ 7 * 3]) >> 1) - 128;
-    pDst[4] = ((pSrc1[ 8 * 3] + pSrc1[ 9 * 3]) >> 1) - 128; pDst[5] = ((pSrc1[10 * 3] + pSrc1[11 * 3]) >> 1) - 128;
-    pDst[6] = ((pSrc1[12 * 3] + pSrc1[13 * 3]) >> 1) - 128; pDst[7] = ((pSrc1[14 * 3] + pSrc1[15 * 3]) >> 1) - 128;
-  }
-}
-
-void jpeg_encoder::load_quantized_coefficients(int component_num)
-{
-  int32 *q = m_quantization_tables[component_num > 0];
-  int16 *pDst = m_coefficient_array;
-  for (int i = 0; i < 64; i++)
-  {
-    sample_array_t j = m_sample_array[s_zag[i]];
-    if (j < 0)
-    {
-      if ((j = -j + (*q >> 1)) < *q)
-        *pDst++ = 0;
-      else
-        *pDst++ = static_cast<int16>(-(j / *q));
-    }
-    else
-    {
-      if ((j = j + (*q >> 1)) < *q)
-        *pDst++ = 0;
-      else
-        *pDst++ = static_cast<int16>((j / *q));
-    }
-    q++;
-  }
-}
-
-void jpeg_encoder::flush_output_buffer()
-{
-  if (m_out_buf_left != JPGE_OUT_BUF_SIZE)
-    m_all_stream_writes_succeeded = m_all_stream_writes_succeeded && m_pStream->put_buf(m_out_buf, JPGE_OUT_BUF_SIZE - m_out_buf_left);
-  m_pOut_buf = m_out_buf;
-  m_out_buf_left = JPGE_OUT_BUF_SIZE;
-}
-
-void jpeg_encoder::put_bits(uint bits, uint len)
-{
-  m_bit_buffer |= ((uint32)bits << (24 - (m_bits_in += len)));
-  while (m_bits_in >= 8)
-  {
-    uint8 c;
-    #define JPGE_PUT_BYTE(c) { *m_pOut_buf++ = (c); if (--m_out_buf_left == 0) flush_output_buffer(); }
-    JPGE_PUT_BYTE(c = (uint8)((m_bit_buffer >> 16) & 0xFF));
-    if (c == 0xFF) JPGE_PUT_BYTE(0);
-    m_bit_buffer <<= 8;
-    m_bits_in -= 8;
-  }
-}
-
-void jpeg_encoder::code_coefficients_pass_one(int component_num)
-{
-  if (component_num >= 3) return; // just to shut up static analysis
-  int i, run_len, nbits, temp1;
-  int16 *src = m_coefficient_array;
-  uint32 *dc_count = component_num ? m_huff_count[0 + 1] : m_huff_count[0 + 0], *ac_count = component_num ? m_huff_count[2 + 1] : m_huff_count[2 + 0];
-
-  temp1 = src[0] - m_last_dc_val[component_num];
-  m_last_dc_val[component_num] = src[0];
-  if (temp1 < 0) temp1 = -temp1;
-
-  nbits = 0;
-  while (temp1)
-  {
-    nbits++; temp1 >>= 1;
-  }
-
-  dc_count[nbits]++;
-  for (run_len = 0, i = 1; i < 64; i++)
-  {
-    if ((temp1 = m_coefficient_array[i]) == 0)
-      run_len++;
-    else
-    {
-      while (run_len >= 16)
-      {
-        ac_count[0xF0]++;
-        run_len -= 16;
-      }
-      if (temp1 < 0) temp1 = -temp1;
-      nbits = 1;
-      while (temp1 >>= 1) nbits++;
-      ac_count[(run_len << 4) + nbits]++;
-      run_len = 0;
-    }
-  }
-  if (run_len) ac_count[0]++;
-}
-
-void jpeg_encoder::code_coefficients_pass_two(int component_num)
-{
-  int i, j, run_len, nbits, temp1, temp2;
-  int16 *pSrc = m_coefficient_array;
-  uint *codes[2];
-  uint8 *code_sizes[2];
-
-  if (component_num == 0)
-  {
-    codes[0] = m_huff_codes[0 + 0]; codes[1] = m_huff_codes[2 + 0];
-    code_sizes[0] = m_huff_code_sizes[0 + 0]; code_sizes[1] = m_huff_code_sizes[2 + 0];
-  }
-  else
-  {
-    codes[0] = m_huff_codes[0 + 1]; codes[1] = m_huff_codes[2 + 1];
-    code_sizes[0] = m_huff_code_sizes[0 + 1]; code_sizes[1] = m_huff_code_sizes[2 + 1];
-  }
-
-  temp1 = temp2 = pSrc[0] - m_last_dc_val[component_num];
-  m_last_dc_val[component_num] = pSrc[0];
-
-  if (temp1 < 0)
-  {
-    temp1 = -temp1; temp2--;
-  }
-
-  nbits = 0;
-  while (temp1)
-  {
-    nbits++; temp1 >>= 1;
-  }
-
-  put_bits(codes[0][nbits], code_sizes[0][nbits]);
-  if (nbits) put_bits(temp2 & ((1 << nbits) - 1), nbits);
-
-  for (run_len = 0, i = 1; i < 64; i++)
-  {
-    if ((temp1 = m_coefficient_array[i]) == 0)
-      run_len++;
-    else
-    {
-      while (run_len >= 16)
-      {
-        put_bits(codes[1][0xF0], code_sizes[1][0xF0]);
-        run_len -= 16;
-      }
-      if ((temp2 = temp1) < 0)
-      {
-        temp1 = -temp1;
-        temp2--;
-      }
-      nbits = 1;
-      while (temp1 >>= 1)
-        nbits++;
-      j = (run_len << 4) + nbits;
-      put_bits(codes[1][j], code_sizes[1][j]);
-      put_bits(temp2 & ((1 << nbits) - 1), nbits);
-      run_len = 0;
-    }
-  }
-  if (run_len)
-    put_bits(codes[1][0], code_sizes[1][0]);
-}
-
-void jpeg_encoder::code_block(int component_num)
-{
-  DCT2D(m_sample_array);
-  load_quantized_coefficients(component_num);
-  if (m_pass_num == 1)
-    code_coefficients_pass_one(component_num);
-  else
-    code_coefficients_pass_two(component_num);
-}
-
-void jpeg_encoder::process_mcu_row()
-{
-  if (m_num_components == 1)
-  {
-    for (int i = 0; i < m_mcus_per_row; i++)
-    {
-      load_block_8_8_grey(i); code_block(0);
-    }
-  }
-  else if ((m_comp_h_samp[0] == 1) && (m_comp_v_samp[0] == 1))
-  {
-    for (int i = 0; i < m_mcus_per_row; i++)
-    {
-      load_block_8_8(i, 0, 0); code_block(0); load_block_8_8(i, 0, 1); code_block(1); load_block_8_8(i, 0, 2); code_block(2);
-    }
-  }
-  else if ((m_comp_h_samp[0] == 2) && (m_comp_v_samp[0] == 1))
-  {
-    for (int i = 0; i < m_mcus_per_row; i++)
-    {
-      load_block_8_8(i * 2 + 0, 0, 0); code_block(0); load_block_8_8(i * 2 + 1, 0, 0); code_block(0);
-      load_block_16_8_8(i, 1); code_block(1); load_block_16_8_8(i, 2); code_block(2);
-    }
-  }
-  else if ((m_comp_h_samp[0] == 2) && (m_comp_v_samp[0] == 2))
-  {
-    for (int i = 0; i < m_mcus_per_row; i++)
-    {
-      load_block_8_8(i * 2 + 0, 0, 0); code_block(0); load_block_8_8(i * 2 + 1, 0, 0); code_block(0);
-      load_block_8_8(i * 2 + 0, 1, 0); code_block(0); load_block_8_8(i * 2 + 1, 1, 0); code_block(0);
-      load_block_16_8(i, 1); code_block(1); load_block_16_8(i, 2); code_block(2);
-    }
-  }
-}
-
-bool jpeg_encoder::terminate_pass_one()
-{
-  optimize_huffman_table(0+0, DC_LUM_CODES); optimize_huffman_table(2+0, AC_LUM_CODES);
-  if (m_num_components > 1)
-  {
-    optimize_huffman_table(0+1, DC_CHROMA_CODES); optimize_huffman_table(2+1, AC_CHROMA_CODES);
-  }
-  return second_pass_init();
-}
-
-bool jpeg_encoder::terminate_pass_two()
-{
-  put_bits(0x7F, 7);
-  flush_output_buffer();
-  emit_marker(M_EOI);
-  m_pass_num++; // purposely bump up m_pass_num, for debugging
-  return true;
-}
-
-bool jpeg_encoder::process_end_of_image()
-{
-  if (m_mcu_y_ofs)
-  {
-    if (m_mcu_y_ofs < 16) // check here just to shut up static analysis
-    {
-      for (int i = m_mcu_y_ofs; i < m_mcu_y; i++)
-        memcpy(m_mcu_lines[i], m_mcu_lines[m_mcu_y_ofs - 1], m_image_bpl_mcu);
-    }
-
-    process_mcu_row();
-  }
-
-  if (m_pass_num == 1)
-    return terminate_pass_one();
-  else
-    return terminate_pass_two();
-}
-
-void jpeg_encoder::load_mcu(const void *pSrc)
-{
-  const uint8* Psrc = reinterpret_cast<const uint8*>(pSrc);
-
-  uint8* pDst = m_mcu_lines[m_mcu_y_ofs]; // OK to write up to m_image_bpl_xlt bytes to pDst
-
-  if (m_num_components == 1)
-  {
-    if (m_image_bpp == 4)
-      RGBA_to_Y(pDst, Psrc, m_image_x);
-    else if (m_image_bpp == 3)
-      RGB_to_Y(pDst, Psrc, m_image_x);
-    else
-      memcpy(pDst, Psrc, m_image_x);
-  }
-  else
-  {
-    if (m_image_bpp == 4)
-      RGBA_to_YCC(pDst, Psrc, m_image_x);
-    else if (m_image_bpp == 3)
-      RGB_to_YCC(pDst, Psrc, m_image_x);
-    else
-      Y_to_YCC(pDst, Psrc, m_image_x);
-  }
-
-  // Possibly duplicate pixels at end of scanline if not a multiple of 8 or 16
-  if (m_num_components == 1)
-    memset(m_mcu_lines[m_mcu_y_ofs] + m_image_bpl_xlt, pDst[m_image_bpl_xlt - 1], m_image_x_mcu - m_image_x);
-  else
-  {
-    const uint8 y = pDst[m_image_bpl_xlt - 3 + 0], cb = pDst[m_image_bpl_xlt - 3 + 1], cr = pDst[m_image_bpl_xlt - 3 + 2];
-    uint8 *q = m_mcu_lines[m_mcu_y_ofs] + m_image_bpl_xlt;
-    for (int i = m_image_x; i < m_image_x_mcu; i++)
-    {
-      *q++ = y; *q++ = cb; *q++ = cr;
-    }
-  }
-
-  if (++m_mcu_y_ofs == m_mcu_y)
-  {
-    process_mcu_row();
-    m_mcu_y_ofs = 0;
-  }
-}
-
-void jpeg_encoder::clear()
-{
-  m_mcu_lines[0] = NULL;
-  m_pass_num = 0;
-  m_all_stream_writes_succeeded = true;
-}
-
-jpeg_encoder::jpeg_encoder()
-{
-  clear();
-}
-
-jpeg_encoder::~jpeg_encoder()
-{
-  deinit();
-}
-
-bool jpeg_encoder::init(output_stream *pStream, int64_t width, int64_t height, int64_t src_channels, const params &comp_params)
-{
-  deinit();
-  if (((!pStream) || (width < 1) || (height < 1)) || ((src_channels != 1) && (src_channels != 3) && (src_channels != 4)) || (!comp_params.check_valid())) return false;
-  m_pStream = pStream;
-  m_params = comp_params;
-  return jpg_open(width, height, src_channels);
-}
-
-void jpeg_encoder::deinit()
-{
-  jpge_free(m_mcu_lines[0]);
-  clear();
-}
-
-bool jpeg_encoder::process_scanline(const void* pScanline)
-{
-  if ((m_pass_num < 1) || (m_pass_num > 2)) return false;
-  if (m_all_stream_writes_succeeded)
-  {
-    if (!pScanline)
-    {
-      if (!process_end_of_image()) return false;
-    }
-    else
-    {
-      load_mcu(pScanline);
-    }
-  }
-  return m_all_stream_writes_succeeded;
-}
-
-// Higher level wrappers/examples (optional).
-#include <stdio.h>
-
-class cfile_stream : public output_stream
-{
-   cfile_stream(const cfile_stream &);
-   cfile_stream &operator= (const cfile_stream &);
-
-   FILE* m_pFile;
-   bool m_bStatus;
-
-public:
-   cfile_stream() : m_pFile(NULL), m_bStatus(false) { }
-
-   virtual ~cfile_stream()
-   {
-      close();
-   }
-
-   bool open(const char *pFilename)
-   {
-      close();
-#if defined(_MSC_VER)
-      if (fopen_s(&m_pFile, pFilename, "wb") != 0)
-	  {
-		  return false;
-	  }
-#else
-      m_pFile = fopen(pFilename, "wb");
-#endif
-      m_bStatus = (m_pFile != NULL);
-      return m_bStatus;
-   }
-
-   bool close()
-   {
-      if (m_pFile)
-      {
-         if (fclose(m_pFile) == EOF)
-         {
-            m_bStatus = false;
-         }
-         m_pFile = NULL;
-      }
-      return m_bStatus;
-   }
-
-   virtual bool put_buf(const void* pBuf, int64_t len)
-   {
-      m_bStatus = m_bStatus && (fwrite(pBuf, len, 1, m_pFile) == 1);
-      return m_bStatus;
-   }
-
-   uint get_size() const
-   {
-      return m_pFile ? ftell(m_pFile) : 0;
-   }
-};
-
-// Writes JPEG image to file.
-bool compress_image_to_jpeg_file(const char *pFilename, int64_t width, int64_t height, int64_t num_channels, const uint8 *pImage_data, const params &comp_params)
-{
-  cfile_stream dst_stream;
-  if (!dst_stream.open(pFilename))
-    return false;
-
-  jpge::jpeg_encoder dst_image;
-  if (!dst_image.init(&dst_stream, width, height, num_channels, comp_params))
-    return false;
-
-  for (uint pass_index = 0; pass_index < dst_image.get_total_passes(); pass_index++)
-  {
-    for (int64_t i = 0; i < height; i++)
-    {
-		// i, width, and num_channels are all 64bit
-       const uint8* pBuf = pImage_data + i * width * num_channels;
-       if (!dst_image.process_scanline(pBuf))
-          return false;
-    }
-    if (!dst_image.process_scanline(NULL))
-       return false;
-  }
-
-  dst_image.deinit();
-
-  return dst_stream.close();
-}
-
-class memory_stream : public output_stream
-{
-   memory_stream(const memory_stream &);
-   memory_stream &operator= (const memory_stream &);
-
-   uint8 *m_pBuf;
-   uint64_t m_buf_size, m_buf_ofs;
-
-public:
-   memory_stream(void *pBuf, uint64_t buf_size) : m_pBuf(static_cast<uint8*>(pBuf)), m_buf_size(buf_size), m_buf_ofs(0) { }
-
-   virtual ~memory_stream() { }
-
-   virtual bool put_buf(const void* pBuf, int64_t len)
-   {
-      uint64_t buf_remaining = m_buf_size - m_buf_ofs;
-      if ((uint64_t)len > buf_remaining)
-         return false;
-      memcpy(m_pBuf + m_buf_ofs, pBuf, len);
-      m_buf_ofs += len;
-      return true;
-   }
-
-   uint64_t get_size() const
-   {
-      return m_buf_ofs;
-   }
-};
-
-bool compress_image_to_jpeg_file_in_memory(void *pDstBuf, int64_t &buf_size, int64_t width, int64_t height, int64_t num_channels, const uint8 *pImage_data, const params &comp_params)
-{
-   if ((!pDstBuf) || (!buf_size))
-      return false;
-
-   memory_stream dst_stream(pDstBuf, buf_size);
-
-   buf_size = 0;
-
-   jpge::jpeg_encoder dst_image;
-   if (!dst_image.init(&dst_stream, width, height, num_channels, comp_params))
-      return false;
-
-   for (uint pass_index = 0; pass_index < dst_image.get_total_passes(); pass_index++)
-   {
-     for (int64_t i = 0; i < height; i++)
-     {
-        const uint8* pScanline = pImage_data + i * width * num_channels;
-        if (!dst_image.process_scanline(pScanline))
-           return false;
-     }
-     if (!dst_image.process_scanline(NULL))
-        return false;
-   }
-
-   dst_image.deinit();
-
-   buf_size = dst_stream.get_size();
-   return true;
-}
-
-} // namespace jpge
\ No newline at end of file
diff --git a/spaces/kcagle/AutoGPT/autogpt/config/__init__.py b/spaces/kcagle/AutoGPT/autogpt/config/__init__.py
deleted file mode 100644
index 726b6dcf3da95968b948c4d897e97a9cdd0928ff..0000000000000000000000000000000000000000
--- a/spaces/kcagle/AutoGPT/autogpt/config/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-"""
-This module contains the configuration classes for AutoGPT.
-"""
-from autogpt.config.ai_config import AIConfig
-from autogpt.config.config import Config, check_openai_api_key
-from autogpt.config.singleton import AbstractSingleton, Singleton
-
-__all__ = [
-    "check_openai_api_key",
-    "AbstractSingleton",
-    "AIConfig",
-    "Config",
-    "Singleton",
-]
diff --git a/spaces/kdrkdrkdr/ProsekaTTS/app.py b/spaces/kdrkdrkdr/ProsekaTTS/app.py
deleted file mode 100644
index c1b3137a2f550f227d5ffc6992c1922789f94330..0000000000000000000000000000000000000000
--- a/spaces/kdrkdrkdr/ProsekaTTS/app.py
+++ /dev/null
@@ -1,173 +0,0 @@
-import json
-import os
-import re
-
-import librosa
-import numpy as np
-import torch
-from torch import no_grad, LongTensor
-import commons
-import utils
-import gradio as gr
-from models import SynthesizerTrn
-from text import text_to_sequence, _clean_text
-from mel_processing import spectrogram_torch
-
-limitation = os.getenv("SYSTEM") == "spaces"  # limit text and audio length in huggingface spaces
-
-
-def get_text(text, hps, is_phoneme):
-    text_norm = text_to_sequence(text, hps.symbols, [] if is_phoneme else hps.data.text_cleaners)
-    if hps.data.add_blank:
-        text_norm = commons.intersperse(text_norm, 0)
-    text_norm = LongTensor(text_norm)
-    return text_norm
-
-
-def create_tts_fn(model, hps, speaker_ids):
-    def tts_fn(text, speaker, speed, is_phoneme):
-        if limitation:
-            text_len = len(text)
-            max_len = 500
-            if is_phoneme:
-                max_len *= 3
-            else:
-                if len(hps.data.text_cleaners) > 0 and hps.data.text_cleaners[0] == "zh_ja_mixture_cleaners":
-                    text_len = len(re.sub("(\[ZH\]|\[JA\])", "", text))
-            if text_len > max_len:
-                return "Error: Text is too long", None
-
-        speaker_id = speaker_ids[speaker]
-        stn_tst = get_text(text, hps, is_phoneme)
-        with no_grad():
-            x_tst = stn_tst.cuda().unsqueeze(0)
-            x_tst_lengths = LongTensor([stn_tst.size(0)]).cuda()
-            sid = LongTensor([speaker_id]).cuda()
-            audio = model.infer(x_tst, x_tst_lengths, sid=sid, noise_scale=.667, noise_scale_w=0.8,
-                                length_scale=1.0 / speed)[0][0, 0].data.cpu().float().numpy()
-        del stn_tst, x_tst, x_tst_lengths, sid
-        return "Success", (hps.data.sampling_rate, audio)
-
-    return tts_fn
-
-
-
-
-
-def create_to_phoneme_fn(hps):
-    def to_phoneme_fn(text):
-        return _clean_text(text, hps.data.text_cleaners) if text != "" else ""
-
-    return to_phoneme_fn
-
-
-css = """
-        #advanced-btn {
-            color: white;
-            border-color: black;
-            background: black;
-            font-size: .7rem !important;
-            line-height: 19px;
-            margin-top: 24px;
-            margin-bottom: 12px;
-            padding: 2px 8px;
-            border-radius: 14px !important;
-        }
-        #advanced-options {
-            display: none;
-            margin-bottom: 20px;
-        }
-"""
-
-if __name__ == '__main__':
-    models_tts = []
-    models_vc = []
-    models_soft_vc = []
-    # {"title": "ハミダシクリエイティブ", "lang": "日本語 (Japanese)", "example":  "こんにちは。", "type": "vits"}
-    name = 'プロセカ TTS'
-    lang = '日本語 (Japanese)'
-    example = 'こんにちは。'
-    config_path = f"saved_model/config.json"
-    model_path = f"saved_model/model.pth"
-    cover_path = f"saved_model/cover.png"
-    hps = utils.get_hparams_from_file(config_path)
-    model = SynthesizerTrn(
-        len(hps.symbols),
-        hps.data.filter_length // 2 + 1,
-        hps.train.segment_size // hps.data.hop_length,
-        n_speakers=hps.data.n_speakers,
-        **hps.model).cuda()
-    utils.load_checkpoint(model_path, model, None)
-    model.eval()
-    speaker_ids = [sid for sid, name in enumerate(hps.speakers) if name != "None"]
-    speakers = [name for sid, name in enumerate(hps.speakers) if name != "None"]
-
-    t = 'vits'
-    models_tts.append((name, cover_path, speakers, lang, example,
-                        hps.symbols, create_tts_fn(model, hps, speaker_ids),
-                        create_to_phoneme_fn(hps)))
-                               
-
-    app = gr.Blocks(css=css)
-
-    with app:
-        gr.Markdown("# Project Sekai TTS Using VITS Model\n\n"
-                    "![visitor badge](https://visitor-badge.glitch.me/badge?page_id=kdrkdrkdr.ProsekaTTS)\n\n")
-        with gr.Tabs():
-            with gr.TabItem("TTS"):
-                with gr.Tabs():
-                    for i, (name, cover_path, speakers, lang, example, symbols, tts_fn,
-                            to_phoneme_fn) in enumerate(models_tts):
-                        with gr.TabItem(f"Proseka"):
-                            with gr.Column():
-                                gr.Markdown(f"## {name}\n\n"
-                                            f"![cover](file/{cover_path})\n\n"
-                                            f"lang: {lang}")
-                                tts_input1 = gr.TextArea(label="Text (500 words limitation)", value=example,
-                                                         elem_id=f"tts-input{i}")
-                                tts_input2 = gr.Dropdown(label="Speaker", choices=speakers,
-                                                         type="index", value=speakers[0])
-                                tts_input3 = gr.Slider(label="Speed", value=1, minimum=0.1, maximum=2, step=0.1)
-                                with gr.Accordion(label="Advanced Options", open=False):
-                                    phoneme_input = gr.Checkbox(value=False, label="Phoneme input")
-                                    to_phoneme_btn = gr.Button("Covert text to phoneme")
-                                    phoneme_list = gr.Dataset(label="Phoneme list", components=[tts_input1],
-                                                              samples=[[x] for x in symbols],
-                                                              elem_id=f"phoneme-list{i}")
-                                    phoneme_list_json = gr.Json(value=symbols, visible=False)
-                                tts_submit = gr.Button("Generate", variant="primary")
-                                tts_output1 = gr.Textbox(label="Output Message")
-                                tts_output2 = gr.Audio(label="Output Audio")
-                                tts_submit.click(tts_fn, [tts_input1, tts_input2, tts_input3, phoneme_input],
-                                                 [tts_output1, tts_output2])
-                                to_phoneme_btn.click(to_phoneme_fn, [tts_input1], [tts_input1])
-                                phoneme_list.click(None, [phoneme_list, phoneme_list_json], [],
-                                                   _js=f"""
-                                (i,phonemes) => {{
-                                    let root = document.querySelector("body > gradio-app");
-                                    if (root.shadowRoot != null)
-                                        root = root.shadowRoot;
-                                    let text_input = root.querySelector("#tts-input{i}").querySelector("textarea");
-                                    let startPos = text_input.selectionStart;
-                                    let endPos = text_input.selectionEnd;
-                                    let oldTxt = text_input.value;
-                                    let result = oldTxt.substring(0, startPos) + phonemes[i] + oldTxt.substring(endPos);
-                                    text_input.value = result;
-                                    let x = window.scrollX, y = window.scrollY;
-                                    text_input.focus();
-                                    text_input.selectionStart = startPos + phonemes[i].length;
-                                    text_input.selectionEnd = startPos + phonemes[i].length;
-                                    text_input.blur();
-                                    window.scrollTo(x, y);
-                                    return [];
-                                }}""")
-
-            
-        gr.Markdown(
-            "Official User Page \n\n"
-            "- [https://github.com/kdrkdrkdr/ProsekaTTS](https://github.com/kdrkdrkdr/ProsekaTTS)\n\n"
-            "Reference \n\n"
-            "- [https://huggingface.co/spaces/skytnt/moe-tts](https://huggingface.co/spaces/skytnt/moe-tts)"
-            
-        )
-    app.queue(concurrency_count=3).launch(show_api=False)
diff --git a/spaces/kenton-li/maia-utsw/README.md b/spaces/kenton-li/maia-utsw/README.md
deleted file mode 100644
index db47a523fb7bbce30c58360477a2036eb5234589..0000000000000000000000000000000000000000
--- a/spaces/kenton-li/maia-utsw/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Maia Utsw
-emoji: 🏢
-colorFrom: green
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/kepl/gpt/g4f/typing.py b/spaces/kepl/gpt/g4f/typing.py
deleted file mode 100644
index e41a567ae49dd26d2ace2a3732b0e8f0bbbaa4b0..0000000000000000000000000000000000000000
--- a/spaces/kepl/gpt/g4f/typing.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from typing import Dict, NewType, Union, Optional, List, get_type_hints
-
-sha256 = NewType('sha_256_hash', str)
\ No newline at end of file
diff --git a/spaces/kevinwang676/ChatGLM2-SadTalker/src/face3d/options/__init__.py b/spaces/kevinwang676/ChatGLM2-SadTalker/src/face3d/options/__init__.py
deleted file mode 100644
index e7eedebe54aa70169fd25951b3034d819e396c90..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/ChatGLM2-SadTalker/src/face3d/options/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""This package options includes option modules: training options, test options, and basic options (used in both training and test)."""
diff --git a/spaces/kevinwang676/ChatGLM2-SadTalker/src/face3d/util/generate_list.py b/spaces/kevinwang676/ChatGLM2-SadTalker/src/face3d/util/generate_list.py
deleted file mode 100644
index 943d906781063c3584a7e5b5c784f8aac0694985..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/ChatGLM2-SadTalker/src/face3d/util/generate_list.py
+++ /dev/null
@@ -1,34 +0,0 @@
-"""This script is to generate training list files for Deep3DFaceRecon_pytorch
-"""
-
-import os
-
-# save path to training data
-def write_list(lms_list, imgs_list, msks_list, mode='train',save_folder='datalist', save_name=''):
-    save_path = os.path.join(save_folder, mode)
-    if not os.path.isdir(save_path):
-        os.makedirs(save_path)
-    with open(os.path.join(save_path, save_name + 'landmarks.txt'), 'w') as fd:
-        fd.writelines([i + '\n' for i in lms_list])
-
-    with open(os.path.join(save_path, save_name + 'images.txt'), 'w') as fd:
-        fd.writelines([i + '\n' for i in imgs_list])
-
-    with open(os.path.join(save_path, save_name + 'masks.txt'), 'w') as fd:
-        fd.writelines([i + '\n' for i in msks_list])   
-
-# check if the path is valid
-def check_list(rlms_list, rimgs_list, rmsks_list):
-    lms_list, imgs_list, msks_list = [], [], []
-    for i in range(len(rlms_list)):
-        flag = 'false'
-        lm_path = rlms_list[i]
-        im_path = rimgs_list[i]
-        msk_path = rmsks_list[i]
-        if os.path.isfile(lm_path) and os.path.isfile(im_path) and os.path.isfile(msk_path):
-            flag = 'true'
-            lms_list.append(rlms_list[i])
-            imgs_list.append(rimgs_list[i])
-            msks_list.append(rmsks_list[i])
-        print(i, rlms_list[i], flag)
-    return lms_list, imgs_list, msks_list
diff --git a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/altair/vegalite/v5/schema/mixins.py b/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/altair/vegalite/v5/schema/mixins.py
deleted file mode 100644
index 569daefb8f3f00c519d350de98e542c7562db1b6..0000000000000000000000000000000000000000
--- a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/altair/vegalite/v5/schema/mixins.py
+++ /dev/null
@@ -1,1292 +0,0 @@
-# The contents of this file are automatically written by
-# tools/generate_schema_wrapper.py. Do not modify directly.
-import sys
-
-from . import core
-from altair.utils import use_signature
-from altair.utils.schemapi import Undefined
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-
-class MarkMethodMixin:
-    """A mixin class that defines mark methods"""
-
-    def mark_arc(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                 ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                 baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                 color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                 cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                 cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                 cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined, dir=Undefined,
-                 discreteBandSize=Undefined, dx=Undefined, dy=Undefined, ellipsis=Undefined,
-                 fill=Undefined, fillOpacity=Undefined, filled=Undefined, font=Undefined,
-                 fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined, height=Undefined,
-                 href=Undefined, innerRadius=Undefined, interpolate=Undefined, invalid=Undefined,
-                 limit=Undefined, line=Undefined, lineBreak=Undefined, lineHeight=Undefined,
-                 opacity=Undefined, order=Undefined, orient=Undefined, outerRadius=Undefined,
-                 padAngle=Undefined, point=Undefined, radius=Undefined, radius2=Undefined,
-                 radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined, size=Undefined,
-                 smooth=Undefined, stroke=Undefined, strokeCap=Undefined, strokeDash=Undefined,
-                 strokeDashOffset=Undefined, strokeJoin=Undefined, strokeMiterLimit=Undefined,
-                 strokeOffset=Undefined, strokeOpacity=Undefined, strokeWidth=Undefined,
-                 style=Undefined, tension=Undefined, text=Undefined, theta=Undefined, theta2=Undefined,
-                 theta2Offset=Undefined, thetaOffset=Undefined, thickness=Undefined,
-                 timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined, tooltip=Undefined,
-                 url=Undefined, width=Undefined, x=Undefined, x2=Undefined, x2Offset=Undefined,
-                 xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined, yOffset=Undefined,
-                 **kwds) -> Self:
-        """Set the chart's mark to 'arc' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="arc", **kwds)
-        else:
-            copy.mark = "arc"
-        return copy
-
-    def mark_area(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                  ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                  baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                  color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                  cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                  cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                  cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                  dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                  ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                  font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                  height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                  invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                  lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                  outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                  radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined,
-                  size=Undefined, smooth=Undefined, stroke=Undefined, strokeCap=Undefined,
-                  strokeDash=Undefined, strokeDashOffset=Undefined, strokeJoin=Undefined,
-                  strokeMiterLimit=Undefined, strokeOffset=Undefined, strokeOpacity=Undefined,
-                  strokeWidth=Undefined, style=Undefined, tension=Undefined, text=Undefined,
-                  theta=Undefined, theta2=Undefined, theta2Offset=Undefined, thetaOffset=Undefined,
-                  thickness=Undefined, timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined,
-                  tooltip=Undefined, url=Undefined, width=Undefined, x=Undefined, x2=Undefined,
-                  x2Offset=Undefined, xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined,
-                  yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'area' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="area", **kwds)
-        else:
-            copy.mark = "area"
-        return copy
-
-    def mark_bar(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                 ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                 baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                 color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                 cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                 cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                 cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined, dir=Undefined,
-                 discreteBandSize=Undefined, dx=Undefined, dy=Undefined, ellipsis=Undefined,
-                 fill=Undefined, fillOpacity=Undefined, filled=Undefined, font=Undefined,
-                 fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined, height=Undefined,
-                 href=Undefined, innerRadius=Undefined, interpolate=Undefined, invalid=Undefined,
-                 limit=Undefined, line=Undefined, lineBreak=Undefined, lineHeight=Undefined,
-                 opacity=Undefined, order=Undefined, orient=Undefined, outerRadius=Undefined,
-                 padAngle=Undefined, point=Undefined, radius=Undefined, radius2=Undefined,
-                 radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined, size=Undefined,
-                 smooth=Undefined, stroke=Undefined, strokeCap=Undefined, strokeDash=Undefined,
-                 strokeDashOffset=Undefined, strokeJoin=Undefined, strokeMiterLimit=Undefined,
-                 strokeOffset=Undefined, strokeOpacity=Undefined, strokeWidth=Undefined,
-                 style=Undefined, tension=Undefined, text=Undefined, theta=Undefined, theta2=Undefined,
-                 theta2Offset=Undefined, thetaOffset=Undefined, thickness=Undefined,
-                 timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined, tooltip=Undefined,
-                 url=Undefined, width=Undefined, x=Undefined, x2=Undefined, x2Offset=Undefined,
-                 xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined, yOffset=Undefined,
-                 **kwds) -> Self:
-        """Set the chart's mark to 'bar' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="bar", **kwds)
-        else:
-            copy.mark = "bar"
-        return copy
-
-    def mark_image(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                   ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                   baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                   color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                   cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                   cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                   cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                   dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                   ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                   font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                   height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                   invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                   lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                   outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                   radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined,
-                   size=Undefined, smooth=Undefined, stroke=Undefined, strokeCap=Undefined,
-                   strokeDash=Undefined, strokeDashOffset=Undefined, strokeJoin=Undefined,
-                   strokeMiterLimit=Undefined, strokeOffset=Undefined, strokeOpacity=Undefined,
-                   strokeWidth=Undefined, style=Undefined, tension=Undefined, text=Undefined,
-                   theta=Undefined, theta2=Undefined, theta2Offset=Undefined, thetaOffset=Undefined,
-                   thickness=Undefined, timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined,
-                   tooltip=Undefined, url=Undefined, width=Undefined, x=Undefined, x2=Undefined,
-                   x2Offset=Undefined, xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined,
-                   yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'image' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="image", **kwds)
-        else:
-            copy.mark = "image"
-        return copy
-
-    def mark_line(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                  ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                  baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                  color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                  cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                  cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                  cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                  dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                  ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                  font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                  height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                  invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                  lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                  outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                  radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined,
-                  size=Undefined, smooth=Undefined, stroke=Undefined, strokeCap=Undefined,
-                  strokeDash=Undefined, strokeDashOffset=Undefined, strokeJoin=Undefined,
-                  strokeMiterLimit=Undefined, strokeOffset=Undefined, strokeOpacity=Undefined,
-                  strokeWidth=Undefined, style=Undefined, tension=Undefined, text=Undefined,
-                  theta=Undefined, theta2=Undefined, theta2Offset=Undefined, thetaOffset=Undefined,
-                  thickness=Undefined, timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined,
-                  tooltip=Undefined, url=Undefined, width=Undefined, x=Undefined, x2=Undefined,
-                  x2Offset=Undefined, xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined,
-                  yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'line' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="line", **kwds)
-        else:
-            copy.mark = "line"
-        return copy
-
-    def mark_point(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                   ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                   baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                   color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                   cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                   cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                   cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                   dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                   ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                   font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                   height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                   invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                   lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                   outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                   radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined,
-                   size=Undefined, smooth=Undefined, stroke=Undefined, strokeCap=Undefined,
-                   strokeDash=Undefined, strokeDashOffset=Undefined, strokeJoin=Undefined,
-                   strokeMiterLimit=Undefined, strokeOffset=Undefined, strokeOpacity=Undefined,
-                   strokeWidth=Undefined, style=Undefined, tension=Undefined, text=Undefined,
-                   theta=Undefined, theta2=Undefined, theta2Offset=Undefined, thetaOffset=Undefined,
-                   thickness=Undefined, timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined,
-                   tooltip=Undefined, url=Undefined, width=Undefined, x=Undefined, x2=Undefined,
-                   x2Offset=Undefined, xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined,
-                   yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'point' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="point", **kwds)
-        else:
-            copy.mark = "point"
-        return copy
-
-    def mark_rect(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                  ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                  baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                  color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                  cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                  cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                  cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                  dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                  ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                  font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                  height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                  invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                  lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                  outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                  radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined,
-                  size=Undefined, smooth=Undefined, stroke=Undefined, strokeCap=Undefined,
-                  strokeDash=Undefined, strokeDashOffset=Undefined, strokeJoin=Undefined,
-                  strokeMiterLimit=Undefined, strokeOffset=Undefined, strokeOpacity=Undefined,
-                  strokeWidth=Undefined, style=Undefined, tension=Undefined, text=Undefined,
-                  theta=Undefined, theta2=Undefined, theta2Offset=Undefined, thetaOffset=Undefined,
-                  thickness=Undefined, timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined,
-                  tooltip=Undefined, url=Undefined, width=Undefined, x=Undefined, x2=Undefined,
-                  x2Offset=Undefined, xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined,
-                  yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'rect' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="rect", **kwds)
-        else:
-            copy.mark = "rect"
-        return copy
-
-    def mark_rule(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                  ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                  baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                  color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                  cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                  cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                  cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                  dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                  ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                  font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                  height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                  invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                  lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                  outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                  radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined,
-                  size=Undefined, smooth=Undefined, stroke=Undefined, strokeCap=Undefined,
-                  strokeDash=Undefined, strokeDashOffset=Undefined, strokeJoin=Undefined,
-                  strokeMiterLimit=Undefined, strokeOffset=Undefined, strokeOpacity=Undefined,
-                  strokeWidth=Undefined, style=Undefined, tension=Undefined, text=Undefined,
-                  theta=Undefined, theta2=Undefined, theta2Offset=Undefined, thetaOffset=Undefined,
-                  thickness=Undefined, timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined,
-                  tooltip=Undefined, url=Undefined, width=Undefined, x=Undefined, x2=Undefined,
-                  x2Offset=Undefined, xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined,
-                  yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'rule' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="rule", **kwds)
-        else:
-            copy.mark = "rule"
-        return copy
-
-    def mark_text(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                  ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                  baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                  color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                  cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                  cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                  cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                  dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                  ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                  font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                  height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                  invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                  lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                  outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                  radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined,
-                  size=Undefined, smooth=Undefined, stroke=Undefined, strokeCap=Undefined,
-                  strokeDash=Undefined, strokeDashOffset=Undefined, strokeJoin=Undefined,
-                  strokeMiterLimit=Undefined, strokeOffset=Undefined, strokeOpacity=Undefined,
-                  strokeWidth=Undefined, style=Undefined, tension=Undefined, text=Undefined,
-                  theta=Undefined, theta2=Undefined, theta2Offset=Undefined, thetaOffset=Undefined,
-                  thickness=Undefined, timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined,
-                  tooltip=Undefined, url=Undefined, width=Undefined, x=Undefined, x2=Undefined,
-                  x2Offset=Undefined, xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined,
-                  yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'text' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="text", **kwds)
-        else:
-            copy.mark = "text"
-        return copy
-
-    def mark_tick(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                  ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                  baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                  color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                  cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                  cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                  cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                  dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                  ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                  font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                  height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                  invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                  lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                  outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                  radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined,
-                  size=Undefined, smooth=Undefined, stroke=Undefined, strokeCap=Undefined,
-                  strokeDash=Undefined, strokeDashOffset=Undefined, strokeJoin=Undefined,
-                  strokeMiterLimit=Undefined, strokeOffset=Undefined, strokeOpacity=Undefined,
-                  strokeWidth=Undefined, style=Undefined, tension=Undefined, text=Undefined,
-                  theta=Undefined, theta2=Undefined, theta2Offset=Undefined, thetaOffset=Undefined,
-                  thickness=Undefined, timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined,
-                  tooltip=Undefined, url=Undefined, width=Undefined, x=Undefined, x2=Undefined,
-                  x2Offset=Undefined, xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined,
-                  yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'tick' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="tick", **kwds)
-        else:
-            copy.mark = "tick"
-        return copy
-
-    def mark_trail(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                   ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                   baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                   color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                   cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                   cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                   cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                   dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                   ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                   font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                   height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                   invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                   lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                   outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                   radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined,
-                   size=Undefined, smooth=Undefined, stroke=Undefined, strokeCap=Undefined,
-                   strokeDash=Undefined, strokeDashOffset=Undefined, strokeJoin=Undefined,
-                   strokeMiterLimit=Undefined, strokeOffset=Undefined, strokeOpacity=Undefined,
-                   strokeWidth=Undefined, style=Undefined, tension=Undefined, text=Undefined,
-                   theta=Undefined, theta2=Undefined, theta2Offset=Undefined, thetaOffset=Undefined,
-                   thickness=Undefined, timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined,
-                   tooltip=Undefined, url=Undefined, width=Undefined, x=Undefined, x2=Undefined,
-                   x2Offset=Undefined, xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined,
-                   yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'trail' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="trail", **kwds)
-        else:
-            copy.mark = "trail"
-        return copy
-
-    def mark_circle(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                    ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                    baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                    color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                    cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                    cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                    cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                    dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                    ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                    font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                    height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                    invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                    lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                    outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                    radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined,
-                    size=Undefined, smooth=Undefined, stroke=Undefined, strokeCap=Undefined,
-                    strokeDash=Undefined, strokeDashOffset=Undefined, strokeJoin=Undefined,
-                    strokeMiterLimit=Undefined, strokeOffset=Undefined, strokeOpacity=Undefined,
-                    strokeWidth=Undefined, style=Undefined, tension=Undefined, text=Undefined,
-                    theta=Undefined, theta2=Undefined, theta2Offset=Undefined, thetaOffset=Undefined,
-                    thickness=Undefined, timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined,
-                    tooltip=Undefined, url=Undefined, width=Undefined, x=Undefined, x2=Undefined,
-                    x2Offset=Undefined, xOffset=Undefined, y=Undefined, y2=Undefined,
-                    y2Offset=Undefined, yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'circle' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="circle", **kwds)
-        else:
-            copy.mark = "circle"
-        return copy
-
-    def mark_square(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                    ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                    baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                    color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                    cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                    cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                    cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                    dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                    ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                    font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                    height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                    invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                    lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                    outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                    radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined, shape=Undefined,
-                    size=Undefined, smooth=Undefined, stroke=Undefined, strokeCap=Undefined,
-                    strokeDash=Undefined, strokeDashOffset=Undefined, strokeJoin=Undefined,
-                    strokeMiterLimit=Undefined, strokeOffset=Undefined, strokeOpacity=Undefined,
-                    strokeWidth=Undefined, style=Undefined, tension=Undefined, text=Undefined,
-                    theta=Undefined, theta2=Undefined, theta2Offset=Undefined, thetaOffset=Undefined,
-                    thickness=Undefined, timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined,
-                    tooltip=Undefined, url=Undefined, width=Undefined, x=Undefined, x2=Undefined,
-                    x2Offset=Undefined, xOffset=Undefined, y=Undefined, y2=Undefined,
-                    y2Offset=Undefined, yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'square' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="square", **kwds)
-        else:
-            copy.mark = "square"
-        return copy
-
-    def mark_geoshape(self, align=Undefined, angle=Undefined, aria=Undefined, ariaRole=Undefined,
-                      ariaRoleDescription=Undefined, aspect=Undefined, bandSize=Undefined,
-                      baseline=Undefined, binSpacing=Undefined, blend=Undefined, clip=Undefined,
-                      color=Undefined, continuousBandSize=Undefined, cornerRadius=Undefined,
-                      cornerRadiusBottomLeft=Undefined, cornerRadiusBottomRight=Undefined,
-                      cornerRadiusEnd=Undefined, cornerRadiusTopLeft=Undefined,
-                      cornerRadiusTopRight=Undefined, cursor=Undefined, description=Undefined,
-                      dir=Undefined, discreteBandSize=Undefined, dx=Undefined, dy=Undefined,
-                      ellipsis=Undefined, fill=Undefined, fillOpacity=Undefined, filled=Undefined,
-                      font=Undefined, fontSize=Undefined, fontStyle=Undefined, fontWeight=Undefined,
-                      height=Undefined, href=Undefined, innerRadius=Undefined, interpolate=Undefined,
-                      invalid=Undefined, limit=Undefined, line=Undefined, lineBreak=Undefined,
-                      lineHeight=Undefined, opacity=Undefined, order=Undefined, orient=Undefined,
-                      outerRadius=Undefined, padAngle=Undefined, point=Undefined, radius=Undefined,
-                      radius2=Undefined, radius2Offset=Undefined, radiusOffset=Undefined,
-                      shape=Undefined, size=Undefined, smooth=Undefined, stroke=Undefined,
-                      strokeCap=Undefined, strokeDash=Undefined, strokeDashOffset=Undefined,
-                      strokeJoin=Undefined, strokeMiterLimit=Undefined, strokeOffset=Undefined,
-                      strokeOpacity=Undefined, strokeWidth=Undefined, style=Undefined,
-                      tension=Undefined, text=Undefined, theta=Undefined, theta2=Undefined,
-                      theta2Offset=Undefined, thetaOffset=Undefined, thickness=Undefined,
-                      timeUnitBandPosition=Undefined, timeUnitBandSize=Undefined, tooltip=Undefined,
-                      url=Undefined, width=Undefined, x=Undefined, x2=Undefined, x2Offset=Undefined,
-                      xOffset=Undefined, y=Undefined, y2=Undefined, y2Offset=Undefined,
-                      yOffset=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'geoshape' (see :class:`MarkDef`)
-        """
-        kwds = dict(align=align, angle=angle, aria=aria, ariaRole=ariaRole,
-                    ariaRoleDescription=ariaRoleDescription, aspect=aspect, bandSize=bandSize,
-                    baseline=baseline, binSpacing=binSpacing, blend=blend, clip=clip, color=color,
-                    continuousBandSize=continuousBandSize, cornerRadius=cornerRadius,
-                    cornerRadiusBottomLeft=cornerRadiusBottomLeft,
-                    cornerRadiusBottomRight=cornerRadiusBottomRight, cornerRadiusEnd=cornerRadiusEnd,
-                    cornerRadiusTopLeft=cornerRadiusTopLeft, cornerRadiusTopRight=cornerRadiusTopRight,
-                    cursor=cursor, description=description, dir=dir, discreteBandSize=discreteBandSize,
-                    dx=dx, dy=dy, ellipsis=ellipsis, fill=fill, fillOpacity=fillOpacity, filled=filled,
-                    font=font, fontSize=fontSize, fontStyle=fontStyle, fontWeight=fontWeight,
-                    height=height, href=href, innerRadius=innerRadius, interpolate=interpolate,
-                    invalid=invalid, limit=limit, line=line, lineBreak=lineBreak, lineHeight=lineHeight,
-                    opacity=opacity, order=order, orient=orient, outerRadius=outerRadius,
-                    padAngle=padAngle, point=point, radius=radius, radius2=radius2,
-                    radius2Offset=radius2Offset, radiusOffset=radiusOffset, shape=shape, size=size,
-                    smooth=smooth, stroke=stroke, strokeCap=strokeCap, strokeDash=strokeDash,
-                    strokeDashOffset=strokeDashOffset, strokeJoin=strokeJoin,
-                    strokeMiterLimit=strokeMiterLimit, strokeOffset=strokeOffset,
-                    strokeOpacity=strokeOpacity, strokeWidth=strokeWidth, style=style, tension=tension,
-                    text=text, theta=theta, theta2=theta2, theta2Offset=theta2Offset,
-                    thetaOffset=thetaOffset, thickness=thickness,
-                    timeUnitBandPosition=timeUnitBandPosition, timeUnitBandSize=timeUnitBandSize,
-                    tooltip=tooltip, url=url, width=width, x=x, x2=x2, x2Offset=x2Offset,
-                    xOffset=xOffset, y=y, y2=y2, y2Offset=y2Offset, yOffset=yOffset, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.MarkDef(type="geoshape", **kwds)
-        else:
-            copy.mark = "geoshape"
-        return copy
-
-    def mark_boxplot(self, box=Undefined, clip=Undefined, color=Undefined, extent=Undefined,
-                     invalid=Undefined, median=Undefined, opacity=Undefined, orient=Undefined,
-                     outliers=Undefined, rule=Undefined, size=Undefined, ticks=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'boxplot' (see :class:`BoxPlotDef`)
-        """
-        kwds = dict(box=box, clip=clip, color=color, extent=extent, invalid=invalid, median=median,
-                    opacity=opacity, orient=orient, outliers=outliers, rule=rule, size=size,
-                    ticks=ticks, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.BoxPlotDef(type="boxplot", **kwds)
-        else:
-            copy.mark = "boxplot"
-        return copy
-
-    def mark_errorbar(self, clip=Undefined, color=Undefined, extent=Undefined, opacity=Undefined,
-                      orient=Undefined, rule=Undefined, size=Undefined, thickness=Undefined,
-                      ticks=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'errorbar' (see :class:`ErrorBarDef`)
-        """
-        kwds = dict(clip=clip, color=color, extent=extent, opacity=opacity, orient=orient, rule=rule,
-                    size=size, thickness=thickness, ticks=ticks, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.ErrorBarDef(type="errorbar", **kwds)
-        else:
-            copy.mark = "errorbar"
-        return copy
-
-    def mark_errorband(self, band=Undefined, borders=Undefined, clip=Undefined, color=Undefined,
-                       extent=Undefined, interpolate=Undefined, opacity=Undefined, orient=Undefined,
-                       tension=Undefined, **kwds) -> Self:
-        """Set the chart's mark to 'errorband' (see :class:`ErrorBandDef`)
-        """
-        kwds = dict(band=band, borders=borders, clip=clip, color=color, extent=extent,
-                    interpolate=interpolate, opacity=opacity, orient=orient, tension=tension, **kwds)
-        copy = self.copy(deep=False)
-        if any(val is not Undefined for val in kwds.values()):
-            copy.mark = core.ErrorBandDef(type="errorband", **kwds)
-        else:
-            copy.mark = "errorband"
-        return copy
-
-
-class ConfigMethodMixin:
-    """A mixin class that defines config methods"""
-
-    @use_signature(core.Config)
-    def configure(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=False)
-        copy.config = core.Config(*args, **kwargs)
-        return copy
-
-    @use_signature(core.RectConfig)
-    def configure_arc(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["arc"] = core.RectConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AreaConfig)
-    def configure_area(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["area"] = core.AreaConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axis(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axis"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisBand(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisBand"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisBottom(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisBottom"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisDiscrete(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisDiscrete"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisLeft(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisLeft"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisPoint(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisPoint"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisQuantitative(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisQuantitative"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisRight(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisRight"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisTemporal(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisTemporal"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisTop(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisTop"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisX(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisX"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisXBand(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisXBand"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisXDiscrete(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisXDiscrete"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisXPoint(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisXPoint"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisXQuantitative(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisXQuantitative"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisXTemporal(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisXTemporal"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisY(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisY"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisYBand(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisYBand"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisYDiscrete(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisYDiscrete"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisYPoint(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisYPoint"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisYQuantitative(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisYQuantitative"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.AxisConfig)
-    def configure_axisYTemporal(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["axisYTemporal"] = core.AxisConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.BarConfig)
-    def configure_bar(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["bar"] = core.BarConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.BoxPlotConfig)
-    def configure_boxplot(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["boxplot"] = core.BoxPlotConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.MarkConfig)
-    def configure_circle(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["circle"] = core.MarkConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.CompositionConfig)
-    def configure_concat(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["concat"] = core.CompositionConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.ErrorBandConfig)
-    def configure_errorband(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["errorband"] = core.ErrorBandConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.ErrorBarConfig)
-    def configure_errorbar(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["errorbar"] = core.ErrorBarConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.CompositionConfig)
-    def configure_facet(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["facet"] = core.CompositionConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.MarkConfig)
-    def configure_geoshape(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["geoshape"] = core.MarkConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.HeaderConfig)
-    def configure_header(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["header"] = core.HeaderConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.HeaderConfig)
-    def configure_headerColumn(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["headerColumn"] = core.HeaderConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.HeaderConfig)
-    def configure_headerFacet(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["headerFacet"] = core.HeaderConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.HeaderConfig)
-    def configure_headerRow(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["headerRow"] = core.HeaderConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.RectConfig)
-    def configure_image(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["image"] = core.RectConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.LegendConfig)
-    def configure_legend(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["legend"] = core.LegendConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.LineConfig)
-    def configure_line(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["line"] = core.LineConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.MarkConfig)
-    def configure_mark(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["mark"] = core.MarkConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.MarkConfig)
-    def configure_point(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["point"] = core.MarkConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.ProjectionConfig)
-    def configure_projection(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["projection"] = core.ProjectionConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.RangeConfig)
-    def configure_range(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["range"] = core.RangeConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.RectConfig)
-    def configure_rect(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["rect"] = core.RectConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.MarkConfig)
-    def configure_rule(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["rule"] = core.MarkConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.ScaleConfig)
-    def configure_scale(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["scale"] = core.ScaleConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.SelectionConfig)
-    def configure_selection(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["selection"] = core.SelectionConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.MarkConfig)
-    def configure_square(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["square"] = core.MarkConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.MarkConfig)
-    def configure_text(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["text"] = core.MarkConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.TickConfig)
-    def configure_tick(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["tick"] = core.TickConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.TitleConfig)
-    def configure_title(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["title"] = core.TitleConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.LineConfig)
-    def configure_trail(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["trail"] = core.LineConfig(*args, **kwargs)
-        return copy
-
-    @use_signature(core.ViewConfig)
-    def configure_view(self, *args, **kwargs) -> Self:
-        copy = self.copy(deep=['config'])
-        if copy.config is Undefined:
-            copy.config = core.Config()
-        copy.config["view"] = core.ViewConfig(*args, **kwargs)
-        return copy
\ No newline at end of file
diff --git a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/charset_normalizer/version.py b/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/charset_normalizer/version.py
deleted file mode 100644
index b74c2643d1e22c31d054e9a0eaa746bc02bbd6dd..0000000000000000000000000000000000000000
--- a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/charset_normalizer/version.py
+++ /dev/null
@@ -1,6 +0,0 @@
-"""
-Expose version
-"""
-
-__version__ = "3.1.0"
-VERSION = __version__.split(".")
diff --git a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/filelock/_unix.py b/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/filelock/_unix.py
deleted file mode 100644
index 641bd8d947c4ac7088f39b95a2cff789696acf3a..0000000000000000000000000000000000000000
--- a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/filelock/_unix.py
+++ /dev/null
@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-import os
-import sys
-from errno import ENOSYS
-from typing import cast
-
-from ._api import BaseFileLock
-
-#: a flag to indicate if the fcntl API is available
-has_fcntl = False
-if sys.platform == "win32":  # pragma: win32 cover
-
-    class UnixFileLock(BaseFileLock):
-        """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
-
-        def _acquire(self) -> None:
-            raise NotImplementedError
-
-        def _release(self) -> None:
-            raise NotImplementedError
-
-else:  # pragma: win32 no cover
-    try:
-        import fcntl
-    except ImportError:
-        pass
-    else:
-        has_fcntl = True
-
-    class UnixFileLock(BaseFileLock):
-        """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
-
-        def _acquire(self) -> None:
-            open_flags = os.O_RDWR | os.O_CREAT | os.O_TRUNC
-            fd = os.open(self.lock_file, open_flags, self._context.mode)
-            try:
-                os.fchmod(fd, self._context.mode)
-            except PermissionError:
-                pass  # This locked is not owned by this UID
-            try:
-                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-            except OSError as exception:
-                os.close(fd)
-                if exception.errno == ENOSYS:  # NotImplemented error
-                    raise NotImplementedError("FileSystem does not appear to support flock; user SoftFileLock instead")
-            else:
-                self._context.lock_file_fd = fd
-
-        def _release(self) -> None:
-            # Do not remove the lockfile:
-            #   https://github.com/tox-dev/py-filelock/issues/31
-            #   https://stackoverflow.com/questions/17708885/flock-removing-locked-file-without-race-condition
-            fd = cast(int, self._context.lock_file_fd)
-            self._context.lock_file_fd = None
-            fcntl.flock(fd, fcntl.LOCK_UN)
-            os.close(fd)
-
-
-__all__ = [
-    "has_fcntl",
-    "UnixFileLock",
-]
diff --git a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/cu2qu/cli.py b/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/cu2qu/cli.py
deleted file mode 100644
index 9144043ff176fb956cf075b5db38fcca88258430..0000000000000000000000000000000000000000
--- a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/cu2qu/cli.py
+++ /dev/null
@@ -1,198 +0,0 @@
-import os
-import argparse
-import logging
-import shutil
-import multiprocessing as mp
-from contextlib import closing
-from functools import partial
-
-import fontTools
-from .ufo import font_to_quadratic, fonts_to_quadratic
-
-ufo_module = None
-try:
-    import ufoLib2 as ufo_module
-except ImportError:
-    try:
-        import defcon as ufo_module
-    except ImportError as e:
-        pass
-
-
-logger = logging.getLogger("fontTools.cu2qu")
-
-
-def _cpu_count():
-    try:
-        return mp.cpu_count()
-    except NotImplementedError:  # pragma: no cover
-        return 1
-
-
-def open_ufo(path):
-    if hasattr(ufo_module.Font, "open"):  # ufoLib2
-        return ufo_module.Font.open(path)
-    return ufo_module.Font(path)  # defcon
-
-
-def _font_to_quadratic(input_path, output_path=None, **kwargs):
-    ufo = open_ufo(input_path)
-    logger.info("Converting curves for %s", input_path)
-    if font_to_quadratic(ufo, **kwargs):
-        logger.info("Saving %s", output_path)
-        if output_path:
-            ufo.save(output_path)
-        else:
-            ufo.save()  # save in-place
-    elif output_path:
-        _copytree(input_path, output_path)
-
-
-def _samepath(path1, path2):
-    # TODO on python3+, there's os.path.samefile
-    path1 = os.path.normcase(os.path.abspath(os.path.realpath(path1)))
-    path2 = os.path.normcase(os.path.abspath(os.path.realpath(path2)))
-    return path1 == path2
-
-
-def _copytree(input_path, output_path):
-    if _samepath(input_path, output_path):
-        logger.debug("input and output paths are the same file; skipped copy")
-        return
-    if os.path.exists(output_path):
-        shutil.rmtree(output_path)
-    shutil.copytree(input_path, output_path)
-
-
-def main(args=None):
-    """Convert a UFO font from cubic to quadratic curves"""
-    parser = argparse.ArgumentParser(prog="cu2qu")
-    parser.add_argument("--version", action="version", version=fontTools.__version__)
-    parser.add_argument(
-        "infiles",
-        nargs="+",
-        metavar="INPUT",
-        help="one or more input UFO source file(s).",
-    )
-    parser.add_argument("-v", "--verbose", action="count", default=0)
-    parser.add_argument(
-        "-e",
-        "--conversion-error",
-        type=float,
-        metavar="ERROR",
-        default=None,
-        help="maxiumum approximation error measured in EM (default: 0.001)",
-    )
-    parser.add_argument(
-        "-m",
-        "--mixed",
-        default=False,
-        action="store_true",
-        help="whether to used mixed quadratic and cubic curves",
-    )
-    parser.add_argument(
-        "--keep-direction",
-        dest="reverse_direction",
-        action="store_false",
-        help="do not reverse the contour direction",
-    )
-
-    mode_parser = parser.add_mutually_exclusive_group()
-    mode_parser.add_argument(
-        "-i",
-        "--interpolatable",
-        action="store_true",
-        help="whether curve conversion should keep interpolation compatibility",
-    )
-    mode_parser.add_argument(
-        "-j",
-        "--jobs",
-        type=int,
-        nargs="?",
-        default=1,
-        const=_cpu_count(),
-        metavar="N",
-        help="Convert using N multiple processes (default: %(default)s)",
-    )
-
-    output_parser = parser.add_mutually_exclusive_group()
-    output_parser.add_argument(
-        "-o",
-        "--output-file",
-        default=None,
-        metavar="OUTPUT",
-        help=(
-            "output filename for the converted UFO. By default fonts are "
-            "modified in place. This only works with a single input."
-        ),
-    )
-    output_parser.add_argument(
-        "-d",
-        "--output-dir",
-        default=None,
-        metavar="DIRECTORY",
-        help="output directory where to save converted UFOs",
-    )
-
-    options = parser.parse_args(args)
-
-    if ufo_module is None:
-        parser.error("Either ufoLib2 or defcon are required to run this script.")
-
-    if not options.verbose:
-        level = "WARNING"
-    elif options.verbose == 1:
-        level = "INFO"
-    else:
-        level = "DEBUG"
-    logging.basicConfig(level=level)
-
-    if len(options.infiles) > 1 and options.output_file:
-        parser.error("-o/--output-file can't be used with multile inputs")
-
-    if options.output_dir:
-        output_dir = options.output_dir
-        if not os.path.exists(output_dir):
-            os.mkdir(output_dir)
-        elif not os.path.isdir(output_dir):
-            parser.error("'%s' is not a directory" % output_dir)
-        output_paths = [
-            os.path.join(output_dir, os.path.basename(p)) for p in options.infiles
-        ]
-    elif options.output_file:
-        output_paths = [options.output_file]
-    else:
-        # save in-place
-        output_paths = [None] * len(options.infiles)
-
-    kwargs = dict(
-        dump_stats=options.verbose > 0,
-        max_err_em=options.conversion_error,
-        reverse_direction=options.reverse_direction,
-        all_quadratic=False if options.mixed else True,
-    )
-
-    if options.interpolatable:
-        logger.info("Converting curves compatibly")
-        ufos = [open_ufo(infile) for infile in options.infiles]
-        if fonts_to_quadratic(ufos, **kwargs):
-            for ufo, output_path in zip(ufos, output_paths):
-                logger.info("Saving %s", output_path)
-                if output_path:
-                    ufo.save(output_path)
-                else:
-                    ufo.save()
-        else:
-            for input_path, output_path in zip(options.infiles, output_paths):
-                if output_path:
-                    _copytree(input_path, output_path)
-    else:
-        jobs = min(len(options.infiles), options.jobs) if options.jobs > 1 else 1
-        if jobs > 1:
-            func = partial(_font_to_quadratic, **kwargs)
-            logger.info("Running %d parallel processes", jobs)
-            with closing(mp.Pool(jobs)) as pool:
-                pool.starmap(func, zip(options.infiles, output_paths))
-        else:
-            for input_path, output_path in zip(options.infiles, output_paths):
-                _font_to_quadratic(input_path, output_path, **kwargs)
diff --git a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/varLib/iup.py b/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/varLib/iup.py
deleted file mode 100644
index 0f1232ad2ea1cac8953239a5bdc55f1cedbb5f02..0000000000000000000000000000000000000000
--- a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/varLib/iup.py
+++ /dev/null
@@ -1,496 +0,0 @@
-try:
-    import cython
-
-    COMPILED = cython.compiled
-except (AttributeError, ImportError):
-    # if cython not installed, use mock module with no-op decorators and types
-    from fontTools.misc import cython
-
-    COMPILED = False
-
-from typing import (
-    Sequence,
-    Tuple,
-    Union,
-)
-from numbers import Integral, Real
-
-try:
-    import cython
-
-    COMPILED = cython.compiled
-except (AttributeError, ImportError):
-    # if cython not installed, use mock module with no-op decorators and types
-    from fontTools.misc import cython
-
-    COMPILED = False
-
-
-_Point = Tuple[Real, Real]
-_Delta = Tuple[Real, Real]
-_PointSegment = Sequence[_Point]
-_DeltaSegment = Sequence[_Delta]
-_DeltaOrNone = Union[_Delta, None]
-_DeltaOrNoneSegment = Sequence[_DeltaOrNone]
-_Endpoints = Sequence[Integral]
-
-
-MAX_LOOKBACK = 8
-
-
-@cython.cfunc
-@cython.locals(
-    j=cython.int,
-    n=cython.int,
-    x1=cython.double,
-    x2=cython.double,
-    d1=cython.double,
-    d2=cython.double,
-    scale=cython.double,
-    x=cython.double,
-    d=cython.double,
-)
-def iup_segment(
-    coords: _PointSegment, rc1: _Point, rd1: _Delta, rc2: _Point, rd2: _Delta
-):  # -> _DeltaSegment:
-    """Given two reference coordinates `rc1` & `rc2` and their respective
-    delta vectors `rd1` & `rd2`, returns interpolated deltas for the set of
-    coordinates `coords`."""
-
-    # rc1 = reference coord 1
-    # rd1 = reference delta 1
-    out_arrays = [None, None]
-    for j in 0, 1:
-        out_arrays[j] = out = []
-        x1, x2, d1, d2 = rc1[j], rc2[j], rd1[j], rd2[j]
-
-        if x1 == x2:
-            n = len(coords)
-            if d1 == d2:
-                out.extend([d1] * n)
-            else:
-                out.extend([0] * n)
-            continue
-
-        if x1 > x2:
-            x1, x2 = x2, x1
-            d1, d2 = d2, d1
-
-        # x1 < x2
-        scale = (d2 - d1) / (x2 - x1)
-        for pair in coords:
-            x = pair[j]
-
-            if x <= x1:
-                d = d1
-            elif x >= x2:
-                d = d2
-            else:
-                # Interpolate
-                d = d1 + (x - x1) * scale
-
-            out.append(d)
-
-    return zip(*out_arrays)
-
-
-def iup_contour(deltas: _DeltaOrNoneSegment, coords: _PointSegment) -> _DeltaSegment:
-    """For the contour given in `coords`, interpolate any missing
-    delta values in delta vector `deltas`.
-
-    Returns fully filled-out delta vector."""
-
-    assert len(deltas) == len(coords)
-    if None not in deltas:
-        return deltas
-
-    n = len(deltas)
-    # indices of points with explicit deltas
-    indices = [i for i, v in enumerate(deltas) if v is not None]
-    if not indices:
-        # All deltas are None.  Return 0,0 for all.
-        return [(0, 0)] * n
-
-    out = []
-    it = iter(indices)
-    start = next(it)
-    if start != 0:
-        # Initial segment that wraps around
-        i1, i2, ri1, ri2 = 0, start, start, indices[-1]
-        out.extend(
-            iup_segment(
-                coords[i1:i2], coords[ri1], deltas[ri1], coords[ri2], deltas[ri2]
-            )
-        )
-    out.append(deltas[start])
-    for end in it:
-        if end - start > 1:
-            i1, i2, ri1, ri2 = start + 1, end, start, end
-            out.extend(
-                iup_segment(
-                    coords[i1:i2], coords[ri1], deltas[ri1], coords[ri2], deltas[ri2]
-                )
-            )
-        out.append(deltas[end])
-        start = end
-    if start != n - 1:
-        # Final segment that wraps around
-        i1, i2, ri1, ri2 = start + 1, n, start, indices[0]
-        out.extend(
-            iup_segment(
-                coords[i1:i2], coords[ri1], deltas[ri1], coords[ri2], deltas[ri2]
-            )
-        )
-
-    assert len(deltas) == len(out), (len(deltas), len(out))
-    return out
-
-
-def iup_delta(
-    deltas: _DeltaOrNoneSegment, coords: _PointSegment, ends: _Endpoints
-) -> _DeltaSegment:
-    """For the outline given in `coords`, with contour endpoints given
-    in sorted increasing order in `ends`, interpolate any missing
-    delta values in delta vector `deltas`.
-
-    Returns fully filled-out delta vector."""
-
-    assert sorted(ends) == ends and len(coords) == (ends[-1] + 1 if ends else 0) + 4
-    n = len(coords)
-    ends = ends + [n - 4, n - 3, n - 2, n - 1]
-    out = []
-    start = 0
-    for end in ends:
-        end += 1
-        contour = iup_contour(deltas[start:end], coords[start:end])
-        out.extend(contour)
-        start = end
-
-    return out
-
-
-# Optimizer
-
-
-@cython.cfunc
-@cython.inline
-@cython.locals(
-    i=cython.int,
-    j=cython.int,
-    tolerance=cython.double,
-    x=cython.double,
-    y=cython.double,
-    p=cython.double,
-    q=cython.double,
-)
-@cython.returns(int)
-def can_iup_in_between(
-    deltas: _DeltaSegment,
-    coords: _PointSegment,
-    i: Integral,
-    j: Integral,
-    tolerance: Real,
-):  # -> bool:
-    """Return true if the deltas for points at `i` and `j` (`i < j`) can be
-    successfully used to interpolate deltas for points in between them within
-    provided error tolerance."""
-
-    assert j - i >= 2
-    interp = iup_segment(coords[i + 1 : j], coords[i], deltas[i], coords[j], deltas[j])
-    deltas = deltas[i + 1 : j]
-
-    return all(
-        abs(complex(x - p, y - q)) <= tolerance
-        for (x, y), (p, q) in zip(deltas, interp)
-    )
-
-
-@cython.locals(
-    cj=cython.double,
-    dj=cython.double,
-    lcj=cython.double,
-    ldj=cython.double,
-    ncj=cython.double,
-    ndj=cython.double,
-    force=cython.int,
-    forced=set,
-)
-def _iup_contour_bound_forced_set(
-    deltas: _DeltaSegment, coords: _PointSegment, tolerance: Real = 0
-) -> set:
-    """The forced set is a conservative set of points on the contour that must be encoded
-    explicitly (ie. cannot be interpolated).  Calculating this set allows for significantly
-    speeding up the dynamic-programming, as well as resolve circularity in DP.
-
-    The set is precise; that is, if an index is in the returned set, then there is no way
-    that IUP can generate delta for that point, given `coords` and `deltas`.
-    """
-    assert len(deltas) == len(coords)
-
-    n = len(deltas)
-    forced = set()
-    # Track "last" and "next" points on the contour as we sweep.
-    for i in range(len(deltas) - 1, -1, -1):
-        ld, lc = deltas[i - 1], coords[i - 1]
-        d, c = deltas[i], coords[i]
-        nd, nc = deltas[i - n + 1], coords[i - n + 1]
-
-        for j in (0, 1):  # For X and for Y
-            cj = c[j]
-            dj = d[j]
-            lcj = lc[j]
-            ldj = ld[j]
-            ncj = nc[j]
-            ndj = nd[j]
-
-            if lcj <= ncj:
-                c1, c2 = lcj, ncj
-                d1, d2 = ldj, ndj
-            else:
-                c1, c2 = ncj, lcj
-                d1, d2 = ndj, ldj
-
-            force = False
-
-            # If the two coordinates are the same, then the interpolation
-            # algorithm produces the same delta if both deltas are equal,
-            # and zero if they differ.
-            #
-            # This test has to be before the next one.
-            if c1 == c2:
-                if abs(d1 - d2) > tolerance and abs(dj) > tolerance:
-                    force = True
-
-            # If coordinate for current point is between coordinate of adjacent
-            # points on the two sides, but the delta for current point is NOT
-            # between delta for those adjacent points (considering tolerance
-            # allowance), then there is no way that current point can be IUP-ed.
-            # Mark it forced.
-            elif c1 <= cj <= c2:  # and c1 != c2
-                if not (min(d1, d2) - tolerance <= dj <= max(d1, d2) + tolerance):
-                    force = True
-
-            # Otherwise, the delta should either match the closest, or have the
-            # same sign as the interpolation of the two deltas.
-            else:  # cj < c1 or c2 < cj
-                if d1 != d2:
-                    if cj < c1:
-                        if (
-                            abs(dj) > tolerance
-                            and abs(dj - d1) > tolerance
-                            and ((dj - tolerance < d1) != (d1 < d2))
-                        ):
-                            force = True
-                    else:  # c2 < cj
-                        if (
-                            abs(dj) > tolerance
-                            and abs(dj - d2) > tolerance
-                            and ((d2 < dj + tolerance) != (d1 < d2))
-                        ):
-                            force = True
-
-            if force:
-                forced.add(i)
-                break
-
-    return forced
-
-
-@cython.locals(
-    i=cython.int,
-    j=cython.int,
-    best_cost=cython.double,
-    best_j=cython.int,
-    cost=cython.double,
-    forced=set,
-    tolerance=cython.double,
-)
-def _iup_contour_optimize_dp(
-    deltas: _DeltaSegment,
-    coords: _PointSegment,
-    forced=set(),
-    tolerance: Real = 0,
-    lookback: Integral = None,
-):
-    """Straightforward Dynamic-Programming.  For each index i, find least-costly encoding of
-    points 0 to i where i is explicitly encoded.  We find this by considering all previous
-    explicit points j and check whether interpolation can fill points between j and i.
-
-    Note that solution always encodes last point explicitly.  Higher-level is responsible
-    for removing that restriction.
-
-    As major speedup, we stop looking further whenever we see a "forced" point."""
-
-    n = len(deltas)
-    if lookback is None:
-        lookback = n
-    lookback = min(lookback, MAX_LOOKBACK)
-    costs = {-1: 0}
-    chain = {-1: None}
-    for i in range(0, n):
-        best_cost = costs[i - 1] + 1
-
-        costs[i] = best_cost
-        chain[i] = i - 1
-
-        if i - 1 in forced:
-            continue
-
-        for j in range(i - 2, max(i - lookback, -2), -1):
-            cost = costs[j] + 1
-
-            if cost < best_cost and can_iup_in_between(deltas, coords, j, i, tolerance):
-                costs[i] = best_cost = cost
-                chain[i] = j
-
-            if j in forced:
-                break
-
-    return chain, costs
-
-
-def _rot_list(l: list, k: int):
-    """Rotate list by k items forward.  Ie. item at position 0 will be
-    at position k in returned list.  Negative k is allowed."""
-    n = len(l)
-    k %= n
-    if not k:
-        return l
-    return l[n - k :] + l[: n - k]
-
-
-def _rot_set(s: set, k: int, n: int):
-    k %= n
-    if not k:
-        return s
-    return {(v + k) % n for v in s}
-
-
-def iup_contour_optimize(
-    deltas: _DeltaSegment, coords: _PointSegment, tolerance: Real = 0.0
-) -> _DeltaOrNoneSegment:
-    """For contour with coordinates `coords`, optimize a set of delta
-    values `deltas` within error `tolerance`.
-
-    Returns delta vector that has most number of None items instead of
-    the input delta.
-    """
-
-    n = len(deltas)
-
-    # Get the easy cases out of the way:
-
-    # If all are within tolerance distance of 0, encode nothing:
-    if all(abs(complex(*p)) <= tolerance for p in deltas):
-        return [None] * n
-
-    # If there's exactly one point, return it:
-    if n == 1:
-        return deltas
-
-    # If all deltas are exactly the same, return just one (the first one):
-    d0 = deltas[0]
-    if all(d0 == d for d in deltas):
-        return [d0] + [None] * (n - 1)
-
-    # Else, solve the general problem using Dynamic Programming.
-
-    forced = _iup_contour_bound_forced_set(deltas, coords, tolerance)
-    # The _iup_contour_optimize_dp() routine returns the optimal encoding
-    # solution given the constraint that the last point is always encoded.
-    # To remove this constraint, we use two different methods, depending on
-    # whether forced set is non-empty or not:
-
-    # Debugging: Make the next if always take the second branch and observe
-    # if the font size changes (reduced); that would mean the forced-set
-    # has members it should not have.
-    if forced:
-        # Forced set is non-empty: rotate the contour start point
-        # such that the last point in the list is a forced point.
-        k = (n - 1) - max(forced)
-        assert k >= 0
-
-        deltas = _rot_list(deltas, k)
-        coords = _rot_list(coords, k)
-        forced = _rot_set(forced, k, n)
-
-        # Debugging: Pass a set() instead of forced variable to the next call
-        # to exercise forced-set computation for under-counting.
-        chain, costs = _iup_contour_optimize_dp(deltas, coords, forced, tolerance)
-
-        # Assemble solution.
-        solution = set()
-        i = n - 1
-        while i is not None:
-            solution.add(i)
-            i = chain[i]
-        solution.remove(-1)
-
-        # if not forced <= solution:
-        # 	print("coord", coords)
-        # 	print("deltas", deltas)
-        # 	print("len", len(deltas))
-        assert forced <= solution, (forced, solution)
-
-        deltas = [deltas[i] if i in solution else None for i in range(n)]
-
-        deltas = _rot_list(deltas, -k)
-    else:
-        # Repeat the contour an extra time, solve the new case, then look for solutions of the
-        # circular n-length problem in the solution for new linear case.  I cannot prove that
-        # this always produces the optimal solution...
-        chain, costs = _iup_contour_optimize_dp(
-            deltas + deltas, coords + coords, forced, tolerance, n
-        )
-        best_sol, best_cost = None, n + 1
-
-        for start in range(n - 1, len(costs) - 1):
-            # Assemble solution.
-            solution = set()
-            i = start
-            while i > start - n:
-                solution.add(i % n)
-                i = chain[i]
-            if i == start - n:
-                cost = costs[start] - costs[start - n]
-                if cost <= best_cost:
-                    best_sol, best_cost = solution, cost
-
-        # if not forced <= best_sol:
-        # 	print("coord", coords)
-        # 	print("deltas", deltas)
-        # 	print("len", len(deltas))
-        assert forced <= best_sol, (forced, best_sol)
-
-        deltas = [deltas[i] if i in best_sol else None for i in range(n)]
-
-    return deltas
-
-
-def iup_delta_optimize(
-    deltas: _DeltaSegment,
-    coords: _PointSegment,
-    ends: _Endpoints,
-    tolerance: Real = 0.0,
-) -> _DeltaOrNoneSegment:
-    """For the outline given in `coords`, with contour endpoints given
-    in sorted increasing order in `ends`, optimize a set of delta
-    values `deltas` within error `tolerance`.
-
-    Returns delta vector that has most number of None items instead of
-    the input delta.
-    """
-    assert sorted(ends) == ends and len(coords) == (ends[-1] + 1 if ends else 0) + 4
-    n = len(coords)
-    ends = ends + [n - 4, n - 3, n - 2, n - 1]
-    out = []
-    start = 0
-    for end in ends:
-        contour = iup_contour_optimize(
-            deltas[start : end + 1], coords[start : end + 1], tolerance
-        )
-        assert len(contour) == end - start + 1
-        out.extend(contour)
-        start = end + 1
-
-    return out
diff --git a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/gradio/external.py b/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/gradio/external.py
deleted file mode 100644
index e3de14d353670de00172fb83155b9e313d415269..0000000000000000000000000000000000000000
--- a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/gradio/external.py
+++ /dev/null
@@ -1,538 +0,0 @@
-"""This module should not be used directly as its API is subject to change. Instead,
-use the `gr.Blocks.load()` or `gr.load()` functions."""
-
-from __future__ import annotations
-
-import json
-import re
-import warnings
-from typing import TYPE_CHECKING, Callable
-
-import requests
-from gradio_client import Client
-from gradio_client.documentation import document, set_documentation_group
-
-import gradio
-from gradio import components, utils
-from gradio.context import Context
-from gradio.exceptions import Error, TooManyRequestsError
-from gradio.external_utils import (
-    cols_to_rows,
-    encode_to_base64,
-    get_tabular_examples,
-    postprocess_label,
-    rows_to_cols,
-    streamline_spaces_interface,
-)
-from gradio.processing_utils import extract_base64_data, to_binary
-
-if TYPE_CHECKING:
-    from gradio.blocks import Blocks
-    from gradio.interface import Interface
-
-
-set_documentation_group("helpers")
-
-
-@document()
-def load(
-    name: str,
-    src: str | None = None,
-    api_key: str | None = None,
-    hf_token: str | None = None,
-    alias: str | None = None,
-    **kwargs,
-) -> Blocks:
-    """
-    Method that constructs a Blocks from a Hugging Face repo. Can accept
-    model repos (if src is "models") or Space repos (if src is "spaces"). The input
-    and output components are automatically loaded from the repo.
-    Parameters:
-        name: the name of the model (e.g. "gpt2" or "facebook/bart-base") or space (e.g. "flax-community/spanish-gpt2"), can include the `src` as prefix (e.g. "models/facebook/bart-base")
-        src: the source of the model: `models` or `spaces` (or leave empty if source is provided as a prefix in `name`)
-        api_key: Deprecated. Please use the `hf_token` parameter instead.
-        hf_token: optional access token for loading private Hugging Face Hub models or spaces. Find your token here: https://huggingface.co/settings/tokens.  Warning: only provide this if you are loading a trusted private Space as it can be read by the Space you are loading.
-        alias: optional string used as the name of the loaded model instead of the default name (only applies if loading a Space running Gradio 2.x)
-    Returns:
-        a Gradio Blocks object for the given model
-    Example:
-        import gradio as gr
-        demo = gr.load("gradio/question-answering", src="spaces")
-        demo.launch()
-    """
-    if hf_token is None and api_key:
-        warnings.warn(
-            "The `api_key` parameter will be deprecated. Please use the `hf_token` parameter going forward."
-        )
-        hf_token = api_key
-    return load_blocks_from_repo(
-        name=name, src=src, api_key=hf_token, alias=alias, **kwargs
-    )
-
-
-def load_blocks_from_repo(
-    name: str,
-    src: str | None = None,
-    api_key: str | None = None,
-    alias: str | None = None,
-    **kwargs,
-) -> Blocks:
-    """Creates and returns a Blocks instance from a Hugging Face model or Space repo."""
-    if src is None:
-        # Separate the repo type (e.g. "model") from repo name (e.g. "google/vit-base-patch16-224")
-        tokens = name.split("/")
-        assert (
-            len(tokens) > 1
-        ), "Either `src` parameter must be provided, or `name` must be formatted as {src}/{repo name}"
-        src = tokens[0]
-        name = "/".join(tokens[1:])
-
-    factory_methods: dict[str, Callable] = {
-        # for each repo type, we have a method that returns the Interface given the model name & optionally an api_key
-        "huggingface": from_model,
-        "models": from_model,
-        "spaces": from_spaces,
-    }
-    assert (
-        src.lower() in factory_methods
-    ), f"parameter: src must be one of {factory_methods.keys()}"
-
-    if api_key is not None:
-        if Context.hf_token is not None and Context.hf_token != api_key:
-            warnings.warn(
-                """You are loading a model/Space with a different access token than the one you used to load a previous model/Space. This is not recommended, as it may cause unexpected behavior."""
-            )
-        Context.hf_token = api_key
-
-    blocks: gradio.Blocks = factory_methods[src](name, api_key, alias, **kwargs)
-    return blocks
-
-
-def chatbot_preprocess(text, state):
-    payload = {
-        "inputs": {"generated_responses": None, "past_user_inputs": None, "text": text}
-    }
-    if state is not None:
-        payload["inputs"]["generated_responses"] = state["conversation"][
-            "generated_responses"
-        ]
-        payload["inputs"]["past_user_inputs"] = state["conversation"][
-            "past_user_inputs"
-        ]
-
-    return payload
-
-
-def chatbot_postprocess(response):
-    response_json = response.json()
-    chatbot_value = list(
-        zip(
-            response_json["conversation"]["past_user_inputs"],
-            response_json["conversation"]["generated_responses"],
-        )
-    )
-    return chatbot_value, response_json
-
-
-def from_model(model_name: str, api_key: str | None, alias: str | None, **kwargs):
-    model_url = f"https://huggingface.co/{model_name}"
-    api_url = f"https://api-inference.huggingface.co/models/{model_name}"
-    print(f"Fetching model from: {model_url}")
-
-    headers = {"Authorization": f"Bearer {api_key}"} if api_key is not None else {}
-
-    # Checking if model exists, and if so, it gets the pipeline
-    response = requests.request("GET", api_url, headers=headers)
-    assert (
-        response.status_code == 200
-    ), f"Could not find model: {model_name}. If it is a private or gated model, please provide your Hugging Face access token (https://huggingface.co/settings/tokens) as the argument for the `api_key` parameter."
-    p = response.json().get("pipeline_tag")
-    pipelines = {
-        "audio-classification": {
-            # example model: ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition
-            "inputs": components.Audio(source="upload", type="filepath", label="Input"),
-            "outputs": components.Label(label="Class"),
-            "preprocess": lambda i: to_binary,
-            "postprocess": lambda r: postprocess_label(
-                {i["label"].split(", ")[0]: i["score"] for i in r.json()}
-            ),
-        },
-        "audio-to-audio": {
-            # example model: facebook/xm_transformer_sm_all-en
-            "inputs": components.Audio(source="upload", type="filepath", label="Input"),
-            "outputs": components.Audio(label="Output"),
-            "preprocess": to_binary,
-            "postprocess": encode_to_base64,
-        },
-        "automatic-speech-recognition": {
-            # example model: facebook/wav2vec2-base-960h
-            "inputs": components.Audio(source="upload", type="filepath", label="Input"),
-            "outputs": components.Textbox(label="Output"),
-            "preprocess": to_binary,
-            "postprocess": lambda r: r.json()["text"],
-        },
-        "conversational": {
-            "inputs": [components.Textbox(), components.State()],  # type: ignore
-            "outputs": [components.Chatbot(), components.State()],  # type: ignore
-            "preprocess": chatbot_preprocess,
-            "postprocess": chatbot_postprocess,
-        },
-        "feature-extraction": {
-            # example model: julien-c/distilbert-feature-extraction
-            "inputs": components.Textbox(label="Input"),
-            "outputs": components.Dataframe(label="Output"),
-            "preprocess": lambda x: {"inputs": x},
-            "postprocess": lambda r: r.json()[0],
-        },
-        "fill-mask": {
-            "inputs": components.Textbox(label="Input"),
-            "outputs": components.Label(label="Classification"),
-            "preprocess": lambda x: {"inputs": x},
-            "postprocess": lambda r: postprocess_label(
-                {i["token_str"]: i["score"] for i in r.json()}
-            ),
-        },
-        "image-classification": {
-            # Example: google/vit-base-patch16-224
-            "inputs": components.Image(type="filepath", label="Input Image"),
-            "outputs": components.Label(label="Classification"),
-            "preprocess": to_binary,
-            "postprocess": lambda r: postprocess_label(
-                {i["label"].split(", ")[0]: i["score"] for i in r.json()}
-            ),
-        },
-        "question-answering": {
-            # Example: deepset/xlm-roberta-base-squad2
-            "inputs": [
-                components.Textbox(lines=7, label="Context"),
-                components.Textbox(label="Question"),
-            ],
-            "outputs": [
-                components.Textbox(label="Answer"),
-                components.Label(label="Score"),
-            ],
-            "preprocess": lambda c, q: {"inputs": {"context": c, "question": q}},
-            "postprocess": lambda r: (r.json()["answer"], {"label": r.json()["score"]}),
-        },
-        "summarization": {
-            # Example: facebook/bart-large-cnn
-            "inputs": components.Textbox(label="Input"),
-            "outputs": components.Textbox(label="Summary"),
-            "preprocess": lambda x: {"inputs": x},
-            "postprocess": lambda r: r.json()[0]["summary_text"],
-        },
-        "text-classification": {
-            # Example: distilbert-base-uncased-finetuned-sst-2-english
-            "inputs": components.Textbox(label="Input"),
-            "outputs": components.Label(label="Classification"),
-            "preprocess": lambda x: {"inputs": x},
-            "postprocess": lambda r: postprocess_label(
-                {i["label"].split(", ")[0]: i["score"] for i in r.json()[0]}
-            ),
-        },
-        "text-generation": {
-            # Example: gpt2
-            "inputs": components.Textbox(label="Input"),
-            "outputs": components.Textbox(label="Output"),
-            "preprocess": lambda x: {"inputs": x},
-            "postprocess": lambda r: r.json()[0]["generated_text"],
-        },
-        "text2text-generation": {
-            # Example: valhalla/t5-small-qa-qg-hl
-            "inputs": components.Textbox(label="Input"),
-            "outputs": components.Textbox(label="Generated Text"),
-            "preprocess": lambda x: {"inputs": x},
-            "postprocess": lambda r: r.json()[0]["generated_text"],
-        },
-        "translation": {
-            "inputs": components.Textbox(label="Input"),
-            "outputs": components.Textbox(label="Translation"),
-            "preprocess": lambda x: {"inputs": x},
-            "postprocess": lambda r: r.json()[0]["translation_text"],
-        },
-        "zero-shot-classification": {
-            # Example: facebook/bart-large-mnli
-            "inputs": [
-                components.Textbox(label="Input"),
-                components.Textbox(label="Possible class names (" "comma-separated)"),
-                components.Checkbox(label="Allow multiple true classes"),
-            ],
-            "outputs": components.Label(label="Classification"),
-            "preprocess": lambda i, c, m: {
-                "inputs": i,
-                "parameters": {"candidate_labels": c, "multi_class": m},
-            },
-            "postprocess": lambda r: postprocess_label(
-                {
-                    r.json()["labels"][i]: r.json()["scores"][i]
-                    for i in range(len(r.json()["labels"]))
-                }
-            ),
-        },
-        "sentence-similarity": {
-            # Example: sentence-transformers/distilbert-base-nli-stsb-mean-tokens
-            "inputs": [
-                components.Textbox(
-                    value="That is a happy person", label="Source Sentence"
-                ),
-                components.Textbox(
-                    lines=7,
-                    placeholder="Separate each sentence by a newline",
-                    label="Sentences to compare to",
-                ),
-            ],
-            "outputs": components.Label(label="Classification"),
-            "preprocess": lambda src, sentences: {
-                "inputs": {
-                    "source_sentence": src,
-                    "sentences": [s for s in sentences.splitlines() if s != ""],
-                }
-            },
-            "postprocess": lambda r: postprocess_label(
-                {f"sentence {i}": v for i, v in enumerate(r.json())}
-            ),
-        },
-        "text-to-speech": {
-            # Example: julien-c/ljspeech_tts_train_tacotron2_raw_phn_tacotron_g2p_en_no_space_train
-            "inputs": components.Textbox(label="Input"),
-            "outputs": components.Audio(label="Audio"),
-            "preprocess": lambda x: {"inputs": x},
-            "postprocess": encode_to_base64,
-        },
-        "text-to-image": {
-            # example model: osanseviero/BigGAN-deep-128
-            "inputs": components.Textbox(label="Input"),
-            "outputs": components.Image(label="Output"),
-            "preprocess": lambda x: {"inputs": x},
-            "postprocess": encode_to_base64,
-        },
-        "token-classification": {
-            # example model: huggingface-course/bert-finetuned-ner
-            "inputs": components.Textbox(label="Input"),
-            "outputs": components.HighlightedText(label="Output"),
-            "preprocess": lambda x: {"inputs": x},
-            "postprocess": lambda r: r,  # Handled as a special case in query_huggingface_api()
-        },
-        "document-question-answering": {
-            # example model: impira/layoutlm-document-qa
-            "inputs": [
-                components.Image(type="filepath", label="Input Document"),
-                components.Textbox(label="Question"),
-            ],
-            "outputs": components.Label(label="Label"),
-            "preprocess": lambda img, q: {
-                "inputs": {
-                    "image": extract_base64_data(img),  # Extract base64 data
-                    "question": q,
-                }
-            },
-            "postprocess": lambda r: postprocess_label(
-                {i["answer"]: i["score"] for i in r.json()}
-            ),
-        },
-        "visual-question-answering": {
-            # example model: dandelin/vilt-b32-finetuned-vqa
-            "inputs": [
-                components.Image(type="filepath", label="Input Image"),
-                components.Textbox(label="Question"),
-            ],
-            "outputs": components.Label(label="Label"),
-            "preprocess": lambda img, q: {
-                "inputs": {
-                    "image": extract_base64_data(img),
-                    "question": q,
-                }
-            },
-            "postprocess": lambda r: postprocess_label(
-                {i["answer"]: i["score"] for i in r.json()}
-            ),
-        },
-        "image-to-text": {
-            # example model: Salesforce/blip-image-captioning-base
-            "inputs": components.Image(type="filepath", label="Input Image"),
-            "outputs": components.Textbox(label="Generated Text"),
-            "preprocess": to_binary,
-            "postprocess": lambda r: r.json()[0]["generated_text"],
-        },
-    }
-
-    if p in ["tabular-classification", "tabular-regression"]:
-        example_data = get_tabular_examples(model_name)
-        col_names, example_data = cols_to_rows(example_data)
-        example_data = [[example_data]] if example_data else None
-
-        pipelines[p] = {
-            "inputs": components.Dataframe(
-                label="Input Rows",
-                type="pandas",
-                headers=col_names,
-                col_count=(len(col_names), "fixed"),
-            ),
-            "outputs": components.Dataframe(
-                label="Predictions", type="array", headers=["prediction"]
-            ),
-            "preprocess": rows_to_cols,
-            "postprocess": lambda r: {
-                "headers": ["prediction"],
-                "data": [[pred] for pred in json.loads(r.text)],
-            },
-            "examples": example_data,
-        }
-
-    if p is None or p not in pipelines:
-        raise ValueError(f"Unsupported pipeline type: {p}")
-
-    pipeline = pipelines[p]
-
-    def query_huggingface_api(*params):
-        # Convert to a list of input components
-        data = pipeline["preprocess"](*params)
-        if isinstance(
-            data, dict
-        ):  # HF doesn't allow additional parameters for binary files (e.g. images or audio files)
-            data.update({"options": {"wait_for_model": True}})
-            data = json.dumps(data)
-        response = requests.request("POST", api_url, headers=headers, data=data)
-        if response.status_code != 200:
-            errors_json = response.json()
-            errors, warns = "", ""
-            if errors_json.get("error"):
-                errors = f", Error: {errors_json.get('error')}"
-            if errors_json.get("warnings"):
-                warns = f", Warnings: {errors_json.get('warnings')}"
-            raise Error(
-                f"Could not complete request to HuggingFace API, Status Code: {response.status_code}"
-                + errors
-                + warns
-            )
-        if (
-            p == "token-classification"
-        ):  # Handle as a special case since HF API only returns the named entities and we need the input as well
-            ner_groups = response.json()
-            input_string = params[0]
-            response = utils.format_ner_list(input_string, ner_groups)
-        output = pipeline["postprocess"](response)
-        return output
-
-    if alias is None:
-        query_huggingface_api.__name__ = model_name
-    else:
-        query_huggingface_api.__name__ = alias
-
-    interface_info = {
-        "fn": query_huggingface_api,
-        "inputs": pipeline["inputs"],
-        "outputs": pipeline["outputs"],
-        "title": model_name,
-        "examples": pipeline.get("examples"),
-    }
-
-    kwargs = dict(interface_info, **kwargs)
-
-    # So interface doesn't run pre/postprocess
-    # except for conversational interfaces which
-    # are stateful
-    kwargs["_api_mode"] = p != "conversational"
-
-    interface = gradio.Interface(**kwargs)
-    return interface
-
-
-def from_spaces(
-    space_name: str, api_key: str | None, alias: str | None, **kwargs
-) -> Blocks:
-    space_url = f"https://huggingface.co/spaces/{space_name}"
-
-    print(f"Fetching Space from: {space_url}")
-
-    headers = {}
-    if api_key is not None:
-        headers["Authorization"] = f"Bearer {api_key}"
-
-    iframe_url = (
-        requests.get(
-            f"https://huggingface.co/api/spaces/{space_name}/host", headers=headers
-        )
-        .json()
-        .get("host")
-    )
-
-    if iframe_url is None:
-        raise ValueError(
-            f"Could not find Space: {space_name}. If it is a private or gated Space, please provide your Hugging Face access token (https://huggingface.co/settings/tokens) as the argument for the `api_key` parameter."
-        )
-
-    r = requests.get(iframe_url, headers=headers)
-
-    result = re.search(
-        r"window.gradio_config = (.*?);[\s]*</script>", r.text
-    )  # some basic regex to extract the config
-    try:
-        config = json.loads(result.group(1))  # type: ignore
-    except AttributeError as ae:
-        raise ValueError(f"Could not load the Space: {space_name}") from ae
-    if "allow_flagging" in config:  # Create an Interface for Gradio 2.x Spaces
-        return from_spaces_interface(
-            space_name, config, alias, api_key, iframe_url, **kwargs
-        )
-    else:  # Create a Blocks for Gradio 3.x Spaces
-        if kwargs:
-            warnings.warn(
-                "You cannot override parameters for this Space by passing in kwargs. "
-                "Instead, please load the Space as a function and use it to create a "
-                "Blocks or Interface locally. You may find this Guide helpful: "
-                "https://gradio.app/using_blocks_like_functions/"
-            )
-        return from_spaces_blocks(space=space_name, api_key=api_key)
-
-
-def from_spaces_blocks(space: str, api_key: str | None) -> Blocks:
-    client = Client(space, hf_token=api_key)
-    predict_fns = [endpoint._predict_resolve for endpoint in client.endpoints]
-    return gradio.Blocks.from_config(client.config, predict_fns, client.src)
-
-
-def from_spaces_interface(
-    model_name: str,
-    config: dict,
-    alias: str | None,
-    api_key: str | None,
-    iframe_url: str,
-    **kwargs,
-) -> Interface:
-    config = streamline_spaces_interface(config)
-    api_url = f"{iframe_url}/api/predict/"
-    headers = {"Content-Type": "application/json"}
-    if api_key is not None:
-        headers["Authorization"] = f"Bearer {api_key}"
-
-    # The function should call the API with preprocessed data
-    def fn(*data):
-        data = json.dumps({"data": data})
-        response = requests.post(api_url, headers=headers, data=data)
-        result = json.loads(response.content.decode("utf-8"))
-        if "error" in result and "429" in result["error"]:
-            raise TooManyRequestsError("Too many requests to the Hugging Face API")
-        try:
-            output = result["data"]
-        except KeyError as ke:
-            raise KeyError(
-                f"Could not find 'data' key in response from external Space. Response received: {result}"
-            ) from ke
-        if (
-            len(config["outputs"]) == 1
-        ):  # if the fn is supposed to return a single value, pop it
-            output = output[0]
-        if len(config["outputs"]) == 1 and isinstance(
-            output, list
-        ):  # Needed to support Output.Image() returning bounding boxes as well (TODO: handle different versions of gradio since they have slightly different APIs)
-            output = output[0]
-        return output
-
-    fn.__name__ = alias if (alias is not None) else model_name
-    config["fn"] = fn
-
-    kwargs = dict(config, **kwargs)
-    kwargs["_api_mode"] = True
-    interface = gradio.Interface(**kwargs)
-    return interface
diff --git a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/matplotlib/_afm.py b/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/matplotlib/_afm.py
deleted file mode 100644
index 3d02d7f9c1d6cdcfc0410ea5e8cba13665163d0e..0000000000000000000000000000000000000000
--- a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/matplotlib/_afm.py
+++ /dev/null
@@ -1,532 +0,0 @@
-"""
-A python interface to Adobe Font Metrics Files.
-
-Although a number of other Python implementations exist, and may be more
-complete than this, it was decided not to go with them because they were
-either:
-
-1) copyrighted or used a non-BSD compatible license
-2) had too many dependencies and a free standing lib was needed
-3) did more than needed and it was easier to write afresh rather than
-   figure out how to get just what was needed.
-
-It is pretty easy to use, and has no external dependencies:
-
->>> import matplotlib as mpl
->>> from pathlib import Path
->>> afm_path = Path(mpl.get_data_path(), 'fonts', 'afm', 'ptmr8a.afm')
->>>
->>> from matplotlib.afm import AFM
->>> with afm_path.open('rb') as fh:
-...     afm = AFM(fh)
->>> afm.string_width_height('What the heck?')
-(6220.0, 694)
->>> afm.get_fontname()
-'Times-Roman'
->>> afm.get_kern_dist('A', 'f')
-0
->>> afm.get_kern_dist('A', 'y')
--92.0
->>> afm.get_bbox_char('!')
-[130, -9, 238, 676]
-
-As in the Adobe Font Metrics File Format Specification, all dimensions
-are given in units of 1/1000 of the scale factor (point size) of the font
-being used.
-"""
-
-from collections import namedtuple
-import logging
-import re
-
-from ._mathtext_data import uni2type1
-
-
-_log = logging.getLogger(__name__)
-
-
-def _to_int(x):
-    # Some AFM files have floats where we are expecting ints -- there is
-    # probably a better way to handle this (support floats, round rather than
-    # truncate).  But I don't know what the best approach is now and this
-    # change to _to_int should at least prevent Matplotlib from crashing on
-    # these.  JDH (2009-11-06)
-    return int(float(x))
-
-
-def _to_float(x):
-    # Some AFM files use "," instead of "." as decimal separator -- this
-    # shouldn't be ambiguous (unless someone is wicked enough to use "," as
-    # thousands separator...).
-    if isinstance(x, bytes):
-        # Encoding doesn't really matter -- if we have codepoints >127 the call
-        # to float() will error anyways.
-        x = x.decode('latin-1')
-    return float(x.replace(',', '.'))
-
-
-def _to_str(x):
-    return x.decode('utf8')
-
-
-def _to_list_of_ints(s):
-    s = s.replace(b',', b' ')
-    return [_to_int(val) for val in s.split()]
-
-
-def _to_list_of_floats(s):
-    return [_to_float(val) for val in s.split()]
-
-
-def _to_bool(s):
-    if s.lower().strip() in (b'false', b'0', b'no'):
-        return False
-    else:
-        return True
-
-
-def _parse_header(fh):
-    """
-    Read the font metrics header (up to the char metrics) and returns
-    a dictionary mapping *key* to *val*.  *val* will be converted to the
-    appropriate python type as necessary; e.g.:
-
-        * 'False'->False
-        * '0'->0
-        * '-168 -218 1000 898'-> [-168, -218, 1000, 898]
-
-    Dictionary keys are
-
-      StartFontMetrics, FontName, FullName, FamilyName, Weight,
-      ItalicAngle, IsFixedPitch, FontBBox, UnderlinePosition,
-      UnderlineThickness, Version, Notice, EncodingScheme, CapHeight,
-      XHeight, Ascender, Descender, StartCharMetrics
-    """
-    header_converters = {
-        b'StartFontMetrics': _to_float,
-        b'FontName': _to_str,
-        b'FullName': _to_str,
-        b'FamilyName': _to_str,
-        b'Weight': _to_str,
-        b'ItalicAngle': _to_float,
-        b'IsFixedPitch': _to_bool,
-        b'FontBBox': _to_list_of_ints,
-        b'UnderlinePosition': _to_float,
-        b'UnderlineThickness': _to_float,
-        b'Version': _to_str,
-        # Some AFM files have non-ASCII characters (which are not allowed by
-        # the spec).  Given that there is actually no public API to even access
-        # this field, just return it as straight bytes.
-        b'Notice': lambda x: x,
-        b'EncodingScheme': _to_str,
-        b'CapHeight': _to_float,  # Is the second version a mistake, or
-        b'Capheight': _to_float,  # do some AFM files contain 'Capheight'? -JKS
-        b'XHeight': _to_float,
-        b'Ascender': _to_float,
-        b'Descender': _to_float,
-        b'StdHW': _to_float,
-        b'StdVW': _to_float,
-        b'StartCharMetrics': _to_int,
-        b'CharacterSet': _to_str,
-        b'Characters': _to_int,
-    }
-    d = {}
-    first_line = True
-    for line in fh:
-        line = line.rstrip()
-        if line.startswith(b'Comment'):
-            continue
-        lst = line.split(b' ', 1)
-        key = lst[0]
-        if first_line:
-            # AFM spec, Section 4: The StartFontMetrics keyword
-            # [followed by a version number] must be the first line in
-            # the file, and the EndFontMetrics keyword must be the
-            # last non-empty line in the file.  We just check the
-            # first header entry.
-            if key != b'StartFontMetrics':
-                raise RuntimeError('Not an AFM file')
-            first_line = False
-        if len(lst) == 2:
-            val = lst[1]
-        else:
-            val = b''
-        try:
-            converter = header_converters[key]
-        except KeyError:
-            _log.error('Found an unknown keyword in AFM header (was %r)' % key)
-            continue
-        try:
-            d[key] = converter(val)
-        except ValueError:
-            _log.error('Value error parsing header in AFM: %s, %s', key, val)
-            continue
-        if key == b'StartCharMetrics':
-            break
-    else:
-        raise RuntimeError('Bad parse')
-    return d
-
-
-CharMetrics = namedtuple('CharMetrics', 'width, name, bbox')
-CharMetrics.__doc__ = """
-    Represents the character metrics of a single character.
-
-    Notes
-    -----
-    The fields do currently only describe a subset of character metrics
-    information defined in the AFM standard.
-    """
-CharMetrics.width.__doc__ = """The character width (WX)."""
-CharMetrics.name.__doc__ = """The character name (N)."""
-CharMetrics.bbox.__doc__ = """
-    The bbox of the character (B) as a tuple (*llx*, *lly*, *urx*, *ury*)."""
-
-
-def _parse_char_metrics(fh):
-    """
-    Parse the given filehandle for character metrics information and return
-    the information as dicts.
-
-    It is assumed that the file cursor is on the line behind
-    'StartCharMetrics'.
-
-    Returns
-    -------
-    ascii_d : dict
-         A mapping "ASCII num of the character" to `.CharMetrics`.
-    name_d : dict
-         A mapping "character name" to `.CharMetrics`.
-
-    Notes
-    -----
-    This function is incomplete per the standard, but thus far parses
-    all the sample afm files tried.
-    """
-    required_keys = {'C', 'WX', 'N', 'B'}
-
-    ascii_d = {}
-    name_d = {}
-    for line in fh:
-        # We are defensively letting values be utf8. The spec requires
-        # ascii, but there are non-compliant fonts in circulation
-        line = _to_str(line.rstrip())  # Convert from byte-literal
-        if line.startswith('EndCharMetrics'):
-            return ascii_d, name_d
-        # Split the metric line into a dictionary, keyed by metric identifiers
-        vals = dict(s.strip().split(' ', 1) for s in line.split(';') if s)
-        # There may be other metrics present, but only these are needed
-        if not required_keys.issubset(vals):
-            raise RuntimeError('Bad char metrics line: %s' % line)
-        num = _to_int(vals['C'])
-        wx = _to_float(vals['WX'])
-        name = vals['N']
-        bbox = _to_list_of_floats(vals['B'])
-        bbox = list(map(int, bbox))
-        metrics = CharMetrics(wx, name, bbox)
-        # Workaround: If the character name is 'Euro', give it the
-        # corresponding character code, according to WinAnsiEncoding (see PDF
-        # Reference).
-        if name == 'Euro':
-            num = 128
-        elif name == 'minus':
-            num = ord("\N{MINUS SIGN}")  # 0x2212
-        if num != -1:
-            ascii_d[num] = metrics
-        name_d[name] = metrics
-    raise RuntimeError('Bad parse')
-
-
-def _parse_kern_pairs(fh):
-    """
-    Return a kern pairs dictionary; keys are (*char1*, *char2*) tuples and
-    values are the kern pair value.  For example, a kern pairs line like
-    ``KPX A y -50``
-
-    will be represented as::
-
-      d[ ('A', 'y') ] = -50
-
-    """
-
-    line = next(fh)
-    if not line.startswith(b'StartKernPairs'):
-        raise RuntimeError('Bad start of kern pairs data: %s' % line)
-
-    d = {}
-    for line in fh:
-        line = line.rstrip()
-        if not line:
-            continue
-        if line.startswith(b'EndKernPairs'):
-            next(fh)  # EndKernData
-            return d
-        vals = line.split()
-        if len(vals) != 4 or vals[0] != b'KPX':
-            raise RuntimeError('Bad kern pairs line: %s' % line)
-        c1, c2, val = _to_str(vals[1]), _to_str(vals[2]), _to_float(vals[3])
-        d[(c1, c2)] = val
-    raise RuntimeError('Bad kern pairs parse')
-
-
-CompositePart = namedtuple('CompositePart', 'name, dx, dy')
-CompositePart.__doc__ = """
-    Represents the information on a composite element of a composite char."""
-CompositePart.name.__doc__ = """Name of the part, e.g. 'acute'."""
-CompositePart.dx.__doc__ = """x-displacement of the part from the origin."""
-CompositePart.dy.__doc__ = """y-displacement of the part from the origin."""
-
-
-def _parse_composites(fh):
-    """
-    Parse the given filehandle for composites information return them as a
-    dict.
-
-    It is assumed that the file cursor is on the line behind 'StartComposites'.
-
-    Returns
-    -------
-    dict
-        A dict mapping composite character names to a parts list. The parts
-        list is a list of `.CompositePart` entries describing the parts of
-        the composite.
-
-    Examples
-    --------
-    A composite definition line::
-
-      CC Aacute 2 ; PCC A 0 0 ; PCC acute 160 170 ;
-
-    will be represented as::
-
-      composites['Aacute'] = [CompositePart(name='A', dx=0, dy=0),
-                              CompositePart(name='acute', dx=160, dy=170)]
-
-    """
-    composites = {}
-    for line in fh:
-        line = line.rstrip()
-        if not line:
-            continue
-        if line.startswith(b'EndComposites'):
-            return composites
-        vals = line.split(b';')
-        cc = vals[0].split()
-        name, _num_parts = cc[1], _to_int(cc[2])
-        pccParts = []
-        for s in vals[1:-1]:
-            pcc = s.split()
-            part = CompositePart(pcc[1], _to_float(pcc[2]), _to_float(pcc[3]))
-            pccParts.append(part)
-        composites[name] = pccParts
-
-    raise RuntimeError('Bad composites parse')
-
-
-def _parse_optional(fh):
-    """
-    Parse the optional fields for kern pair data and composites.
-
-    Returns
-    -------
-    kern_data : dict
-        A dict containing kerning information. May be empty.
-        See `._parse_kern_pairs`.
-    composites : dict
-        A dict containing composite information. May be empty.
-        See `._parse_composites`.
-    """
-    optional = {
-        b'StartKernData': _parse_kern_pairs,
-        b'StartComposites':  _parse_composites,
-        }
-
-    d = {b'StartKernData': {},
-         b'StartComposites': {}}
-    for line in fh:
-        line = line.rstrip()
-        if not line:
-            continue
-        key = line.split()[0]
-
-        if key in optional:
-            d[key] = optional[key](fh)
-
-    return d[b'StartKernData'], d[b'StartComposites']
-
-
-class AFM:
-
-    def __init__(self, fh):
-        """Parse the AFM file in file object *fh*."""
-        self._header = _parse_header(fh)
-        self._metrics, self._metrics_by_name = _parse_char_metrics(fh)
-        self._kern, self._composite = _parse_optional(fh)
-
-    def get_bbox_char(self, c, isord=False):
-        if not isord:
-            c = ord(c)
-        return self._metrics[c].bbox
-
-    def string_width_height(self, s):
-        """
-        Return the string width (including kerning) and string height
-        as a (*w*, *h*) tuple.
-        """
-        if not len(s):
-            return 0, 0
-        total_width = 0
-        namelast = None
-        miny = 1e9
-        maxy = 0
-        for c in s:
-            if c == '\n':
-                continue
-            wx, name, bbox = self._metrics[ord(c)]
-
-            total_width += wx + self._kern.get((namelast, name), 0)
-            l, b, w, h = bbox
-            miny = min(miny, b)
-            maxy = max(maxy, b + h)
-
-            namelast = name
-
-        return total_width, maxy - miny
-
-    def get_str_bbox_and_descent(self, s):
-        """Return the string bounding box and the maximal descent."""
-        if not len(s):
-            return 0, 0, 0, 0, 0
-        total_width = 0
-        namelast = None
-        miny = 1e9
-        maxy = 0
-        left = 0
-        if not isinstance(s, str):
-            s = _to_str(s)
-        for c in s:
-            if c == '\n':
-                continue
-            name = uni2type1.get(ord(c), f"uni{ord(c):04X}")
-            try:
-                wx, _, bbox = self._metrics_by_name[name]
-            except KeyError:
-                name = 'question'
-                wx, _, bbox = self._metrics_by_name[name]
-            total_width += wx + self._kern.get((namelast, name), 0)
-            l, b, w, h = bbox
-            left = min(left, l)
-            miny = min(miny, b)
-            maxy = max(maxy, b + h)
-
-            namelast = name
-
-        return left, miny, total_width, maxy - miny, -miny
-
-    def get_str_bbox(self, s):
-        """Return the string bounding box."""
-        return self.get_str_bbox_and_descent(s)[:4]
-
-    def get_name_char(self, c, isord=False):
-        """Get the name of the character, i.e., ';' is 'semicolon'."""
-        if not isord:
-            c = ord(c)
-        return self._metrics[c].name
-
-    def get_width_char(self, c, isord=False):
-        """
-        Get the width of the character from the character metric WX field.
-        """
-        if not isord:
-            c = ord(c)
-        return self._metrics[c].width
-
-    def get_width_from_char_name(self, name):
-        """Get the width of the character from a type1 character name."""
-        return self._metrics_by_name[name].width
-
-    def get_height_char(self, c, isord=False):
-        """Get the bounding box (ink) height of character *c* (space is 0)."""
-        if not isord:
-            c = ord(c)
-        return self._metrics[c].bbox[-1]
-
-    def get_kern_dist(self, c1, c2):
-        """
-        Return the kerning pair distance (possibly 0) for chars *c1* and *c2*.
-        """
-        name1, name2 = self.get_name_char(c1), self.get_name_char(c2)
-        return self.get_kern_dist_from_name(name1, name2)
-
-    def get_kern_dist_from_name(self, name1, name2):
-        """
-        Return the kerning pair distance (possibly 0) for chars
-        *name1* and *name2*.
-        """
-        return self._kern.get((name1, name2), 0)
-
-    def get_fontname(self):
-        """Return the font name, e.g., 'Times-Roman'."""
-        return self._header[b'FontName']
-
-    @property
-    def postscript_name(self):  # For consistency with FT2Font.
-        return self.get_fontname()
-
-    def get_fullname(self):
-        """Return the font full name, e.g., 'Times-Roman'."""
-        name = self._header.get(b'FullName')
-        if name is None:  # use FontName as a substitute
-            name = self._header[b'FontName']
-        return name
-
-    def get_familyname(self):
-        """Return the font family name, e.g., 'Times'."""
-        name = self._header.get(b'FamilyName')
-        if name is not None:
-            return name
-
-        # FamilyName not specified so we'll make a guess
-        name = self.get_fullname()
-        extras = (r'(?i)([ -](regular|plain|italic|oblique|bold|semibold|'
-                  r'light|ultralight|extra|condensed))+$')
-        return re.sub(extras, '', name)
-
-    @property
-    def family_name(self):
-        """The font family name, e.g., 'Times'."""
-        return self.get_familyname()
-
-    def get_weight(self):
-        """Return the font weight, e.g., 'Bold' or 'Roman'."""
-        return self._header[b'Weight']
-
-    def get_angle(self):
-        """Return the fontangle as float."""
-        return self._header[b'ItalicAngle']
-
-    def get_capheight(self):
-        """Return the cap height as float."""
-        return self._header[b'CapHeight']
-
-    def get_xheight(self):
-        """Return the xheight as float."""
-        return self._header[b'XHeight']
-
-    def get_underline_thickness(self):
-        """Return the underline thickness as float."""
-        return self._header[b'UnderlineThickness']
-
-    def get_horizontal_stem_width(self):
-        """
-        Return the standard horizontal stem width as float, or *None* if
-        not specified in AFM file.
-        """
-        return self._header.get(b'StdHW', None)
-
-    def get_vertical_stem_width(self):
-        """
-        Return the standard vertical stem width as float, or *None* if
-        not specified in AFM file.
-        """
-        return self._header.get(b'StdVW', None)
diff --git a/spaces/ky2k/image_denoise_demo/models.py b/spaces/ky2k/image_denoise_demo/models.py
deleted file mode 100644
index b1bc65eb83b377fc758cf00143196f5b9fcd4cf3..0000000000000000000000000000000000000000
--- a/spaces/ky2k/image_denoise_demo/models.py
+++ /dev/null
@@ -1,276 +0,0 @@
-import os, cv2
-import numpy as np
-from network_configure import conf_unet
-from network import *
-from utils.predict_utils import get_coord, PercentileNormalizer, PadAndCropResizer
-from utils.train_utils import augment_patch
-from utils import train_utils
-
-# UNet implementation inherited from GVTNets: https://github.com/zhengyang-wang/GVTNets
-training_config = {'base_learning_rate': 0.0004,
-                                     'lr_decay_steps':5e3, 
-                                     'lr_decay_rate':0.5, 
-                                     'lr_staircase':True}
-
-class Noise2Same(object):
-
-    def __init__(self, base_dir, name, 
-                 dim=2, in_channels=1, lmbd=None, 
-                 masking='gaussian', mask_perc=0.5,
-                 opt_config=training_config, **kwargs):
-
-        self.base_dir = base_dir # model direction
-        self.name = name # model name
-        self.dim = dim # image dimension
-        self.in_channels = in_channels # image channels
-        self.lmbd = lmbd # lambda in loss fn
-        self.masking = masking
-        self.mask_perc = mask_perc
-        
-        self.opt_config = opt_config
-        conf_unet['dimension'] = '%dD'%dim
-        self.net = UNet(conf_unet)
-        
-    def _model_fn(self, features, labels, mode):
-        conv_op = convolution_2D if self.dim==2 else convolution_3D
-        axis = {3:[1,2,3,4], 2:[1,2,3]}[self.dim]
-        
-        def image_summary(img):
-            return tf.reduce_max(img, axis=1) if self.dim == 3 else img
-        
-        # Local average excluding the center pixel (donut)
-        def mask_kernel(features):
-            kernel = (np.array([[0.5, 1.0, 0.5], [1.0, 0.0, 1.0], [0.5, 1.0, 0.5]]) 
-                      if self.dim == 2 else 
-                      np.array([[[0, 0.5, 0], [0.5, 1.0, 0.5], [0, 0.5, 0]],
-                                [[0.5, 1.0, 0.5], [1.0, 0.0, 1.0], [0.5, 1.0, 0.5]],
-                                [[0, 0.5, 0], [0.5, 1.0, 0.5], [0, 0.5, 0]]]))
-            kernel = (kernel/kernel.sum())
-            kernels = np.empty([3, 3, self.in_channels, self.in_channels])
-            for i in range(self.in_channels):
-                kernels[:,:,i,i] = kernel
-            nn_conv_op = tf.nn.conv2d if self.dim == 2 else tf.nn.conv3d
-            return nn_conv_op(features, tf.constant(kernels.astype('float32')), 
-                              [1]*self.dim+[1,1], padding='SAME')
-        
-        if not mode == tf.estimator.ModeKeys.PREDICT:
-            noise, mask = tf.split(labels, [self.in_channels, self.in_channels], -1)
-            
-            if self.masking == 'gaussian':
-                masked_features = (1 - mask) * features + mask * noise
-            elif self.masking == 'donut':
-                masked_features = (1 - mask) * features + mask * mask_kernel(features)
-            else:
-                raise NotImplementedError
-            
-            # Prediction from masked input
-            with tf.variable_scope('main_unet', reuse=tf.compat.v1.AUTO_REUSE):
-                out = self.net(masked_features, mode == tf.estimator.ModeKeys.TRAIN)
-                out = batch_norm(out, mode == tf.estimator.ModeKeys.TRAIN, 'unet_out')
-                out = relu(out)
-                preds = conv_op(out, self.in_channels, 1, 1, False, name = 'out_conv')
-                
-            # Prediction from full input
-            with tf.variable_scope('main_unet', reuse=tf.compat.v1.AUTO_REUSE):
-                rawout = self.net(features, mode == tf.estimator.ModeKeys.TRAIN)
-                rawout = batch_norm(rawout, mode == tf.estimator.ModeKeys.TRAIN, 'unet_out')
-                rawout = relu(rawout)
-                rawpreds = conv_op(rawout, self.in_channels, 1, 1, False, name = 'out_conv')
-            
-            # Loss components
-            rec_mse = tf.reduce_mean(tf.square(rawpreds - features), axis=None)
-            inv_mse = tf.reduce_sum(tf.square(rawpreds - preds) * mask) / tf.reduce_sum(mask)
-            bsp_mse = tf.reduce_sum(tf.square(features - preds) * mask) / tf.reduce_sum(mask)
-
-            # Tensorboard display
-            tf.summary.image('1_inputs', image_summary(features), max_outputs=3)
-            tf.summary.image('2_raw_predictions', image_summary(rawpreds), max_outputs=3)
-            tf.summary.image('3_mask', image_summary(mask), max_outputs=3)
-            tf.summary.image('4_masked_predictions', image_summary(preds), max_outputs=3)
-            tf.summary.image('5_difference', image_summary(rawpreds-preds), max_outputs=3)
-            tf.summary.image('6_rec_error', image_summary(preds-features), max_outputs=3)
-            tf.summary.scalar('reconstruction', rec_mse, family='loss_metric') 
-            tf.summary.scalar('invariance', inv_mse, family='loss_metric') 
-            tf.summary.scalar('blind_spot', bsp_mse, family='loss_metric')
-                
-        else:
-            with tf.variable_scope('main_unet'):
-                out = self.net(features, mode == tf.estimator.ModeKeys.TRAIN)
-                out = batch_norm(out, mode == tf.estimator.ModeKeys.TRAIN, 'unet_out')
-                out = relu(out)
-                preds = conv_op(out, self.in_channels, 1, 1, False, name = 'out_conv')
-            return tf.estimator.EstimatorSpec(mode=mode, predictions=preds)
-        
-        lmbd = 2 if self.lmbd is None else self.lmbd
-        loss = rec_mse + lmbd*tf.sqrt(inv_mse)
-
-        if mode == tf.estimator.ModeKeys.TRAIN:
-            global_step = tf.train.get_or_create_global_step()
-            learning_rate = tf.train.exponential_decay(self.opt_config['base_learning_rate'], 
-                                                       global_step, 
-                                                       self.opt_config['lr_decay_steps'], 
-                                                       self.opt_config['lr_decay_rate'], 
-                                                       self.opt_config['lr_staircase'])
-            optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
-
-            update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='main_unet')
-            with tf.control_dependencies(update_ops):
-                train_op = optimizer.minimize(loss, global_step)
-        else:
-            train_op = None
-        
-        metrics = {'loss_metric/invariance':tf.metrics.mean(inv_mse),
-                              'loss_metric/blind_spot':tf.metrics.mean(bsp_mse), 
-                              'loss_metric/reconstruction':tf.metrics.mean(rec_mse)}
-        
-        return tf.estimator.EstimatorSpec(mode=mode, predictions=preds, loss=loss, train_op=train_op, 
-                                          eval_metric_ops=metrics)
-
-
-    def _input_fn(self, sources, patch_size, batch_size, is_train=True):
-        # Stratified sampling inherited from Noise2Void: https://github.com/juglab/n2v
-        get_stratified_coords = getattr(train_utils, 'get_stratified_coords%dD'%self.dim)
-        rand_float_coords = getattr(train_utils, 'rand_float_coords%dD'%self.dim)
-        
-        def generator():
-            while(True):
-                source = sources[np.random.randint(len(sources))]
-                valid_shape = source.shape[:-1] - np.array(patch_size)
-                if any([s<=0 for s in valid_shape]):
-                    source_patch = augment_patch(source)
-                else:
-                    coords = [np.random.randint(0, shape_i+1) for shape_i in valid_shape]
-                    s = tuple([slice(coord, coord+size) for coord, size in zip(coords, patch_size)])
-                    source_patch = augment_patch(source[s])
-                
-                mask = np.zeros_like(source_patch)
-                for c in range(self.in_channels):
-                    boxsize = np.round(np.sqrt(100/self.mask_perc)).astype(np.int)
-                    maskcoords = get_stratified_coords(rand_float_coords(boxsize), 
-                                                       box_size=boxsize, shape=tuple(patch_size))
-                    indexing = maskcoords + (c,)
-                    mask[indexing] = 1.0
-
-                noise_patch = np.concatenate([np.random.normal(0, 0.2, source_patch.shape), mask], axis=-1)
-                yield source_patch, noise_patch
-                
-        def generator_val():
-            for idx in range(len(sources)):
-                source_patch = sources[idx]
-                patch_size = source_patch.shape[:-1]
-                boxsize = np.round(np.sqrt(100/self.mask_perc)).astype(np.int)
-                maskcoords = get_stratified_coords(rand_float_coords(boxsize), 
-                                                   box_size=boxsize, shape=tuple(patch_size))
-                indexing = maskcoords + (0,)
-                mask = np.zeros_like(source_patch)
-                mask[indexing] = 1.0
-                noise_patch = np.concatenate([np.random.normal(0, 0.2, source_patch.shape), mask], axis=-1)
-                yield source_patch, noise_patch
-
-        output_types = (tf.float32, tf.float32)
-        output_shapes = (tf.TensorShape(list(patch_size) + [self.in_channels]), 
-                                             tf.TensorShape(list(patch_size) + [self.in_channels*2]))
-        gen = generator if is_train else generator_val
-        dataset = tf.data.Dataset.from_generator(gen, output_types=output_types, output_shapes=output_shapes)
-        dataset = dataset.batch(batch_size).prefetch(tf.data.experimental.AUTOTUNE)
-
-        return dataset
-
-
-    def train(self, source_lst, patch_size, validation=None, batch_size=64, save_steps=1000, log_steps=200, steps=50000):
-        assert len(patch_size)==self.dim
-        assert len(source_lst[0].shape)==self.dim + 1
-        assert source_lst[0].shape[-1]==self.in_channels
-
-        ses_config = tf.ConfigProto()
-        ses_config.gpu_options.allow_growth = True
-
-        run_config = tf.estimator.RunConfig(model_dir=self.base_dir+'/'+self.name, 
-                                            save_checkpoints_steps=save_steps,
-                                            session_config=ses_config, 
-                                            log_step_count_steps=log_steps,
-                                            save_summary_steps=log_steps,
-                                            keep_checkpoint_max=2)
-
-        estimator = tf.estimator.Estimator(model_fn=self._model_fn, 
-                                             model_dir=self.base_dir+'/'+self.name, 
-                                             config=run_config)
-        
-        input_fn = lambda: self._input_fn(source_lst, patch_size, batch_size=batch_size)
-        
-        if validation is not None:
-            train_spec = tf.estimator.TrainSpec(input_fn=input_fn, max_steps=steps)
-            val_input_fn = lambda: self._input_fn(validation.astype('float32'), 
-                                                  validation.shape[1:-1], 
-                                                  batch_size=4, 
-                                                  is_train=False)
-            eval_spec = tf.estimator.EvalSpec(input_fn=val_input_fn, throttle_secs=120)
-            tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
-        else:
-            estimator.train(input_fn=input_fn, steps=steps)
-            
-
-    # Used for single image prediction
-    def predict(self, image, resizer=PadAndCropResizer(), checkpoint_path=None,
-               im_mean=None, im_std=None):
-
-        tf.logging.set_verbosity(tf.logging.ERROR)
-        estimator = tf.estimator.Estimator(model_fn=self._model_fn, 
-                                            model_dir=self.base_dir+'/'+self.name)
-        
-        im_mean, im_std = ((image.mean(), image.std()) if im_mean is None or im_std is None else (im_mean, im_std)) 
-        image = (image - im_mean)/im_std
-        if self.in_channels == 1:
-            image = resizer.before(image, 2 ** (self.net.depth), exclude=None)
-            input_fn = tf.estimator.inputs.numpy_input_fn(x=image[None, ..., None], batch_size=1, num_epochs=1, shuffle=False)
-            image = list(estimator.predict(input_fn=input_fn, checkpoint_path=checkpoint_path))[0][..., 0]
-            image = resizer.after(image, exclude=None)
-        else:
-            image = resizer.before(image, 2 ** (self.net.depth), exclude=-1)
-            input_fn = tf.estimator.inputs.numpy_input_fn(x=image[None], batch_size=1, num_epochs=1, shuffle=False)
-            image = list(estimator.predict(input_fn=input_fn, checkpoint_path=checkpoint_path))[0]
-            image = resizer.after(image, exclude=-1)
-        image = image*im_std + im_mean
-
-        return image
-    
-    # Used for batch images prediction
-    def batch_predict(self, images, resizer=PadAndCropResizer(), checkpoint_path=None,
-               im_mean=None, im_std=None, batch_size=32):
-
-        tf.logging.set_verbosity(tf.logging.ERROR)
-        estimator = tf.estimator.Estimator(model_fn=self._model_fn, 
-                                            model_dir=self.base_dir+'/'+self.name)
-        
-        im_mean, im_std = ((images.mean(), images.std()) if im_mean is None or im_std is None else (im_mean, im_std)) 
-        
-        images = (images - im_mean)/im_std
-        images = resizer.before(images, 2 ** (self.net.depth), exclude=0)
-        input_fn = tf.estimator.inputs.numpy_input_fn(x=images[ ..., None], batch_size=batch_size, num_epochs=1, shuffle=False)
-        images = np.stack(list(estimator.predict(input_fn=input_fn, checkpoint_path=checkpoint_path)))[..., 0]
-        images = resizer.after(images, exclude=0)
-        images = images*im_std + im_mean
-
-        return images
-
-    # Used for extremely large input images
-    def crop_predict(self, image, size, margin, resizer=PadAndCropResizer(), checkpoint_path=None,
-               im_mean=None, im_std=None):
-
-        tf.logging.set_verbosity(tf.logging.ERROR)
-        estimator = tf.estimator.Estimator(model_fn=self._model_fn, 
-                                            model_dir=self.base_dir+'/'+self.name)
-        
-        im_mean, im_std = ((image.mean(), image.std()) if im_mean is None or im_std is None else (im_mean, im_std)) 
-        image = (image - im_mean)/im_std
-        out_image = np.empty(image.shape, dtype='float32')
-        for src_s, trg_s, mrg_s in get_coord(image.shape, size, margin):
-            patch = resizer.before(image[src_s], 2 ** (self.net.depth), exclude=None)
-            input_fn = tf.estimator.inputs.numpy_input_fn(x=patch[None, ..., None], batch_size=1, num_epochs=1, shuffle=False)
-            patch = list(estimator.predict(input_fn=input_fn, checkpoint_path=checkpoint_path))[0][..., 0]
-            patch = resizer.after(patch, exclude=None)
-            out_image[trg_s] = patch[mrg_s]
-            
-        image = out_image*im_std + im_mean
-
-        return image
diff --git a/spaces/kyotoyx/medical-diagnosis/app.py b/spaces/kyotoyx/medical-diagnosis/app.py
deleted file mode 100644
index 0c2724eb62631bb1aa7cbe259be21860a45160e6..0000000000000000000000000000000000000000
--- a/spaces/kyotoyx/medical-diagnosis/app.py
+++ /dev/null
@@ -1,4 +0,0 @@
-import streamlit as st
-
-x = st.slider('Select a value')
-st.write(x, 'squared is', x * x)
diff --git a/spaces/latent-consistency/Real-Time-LCM-ControlNet-Lora-SD1.5/static/img2img.html b/spaces/latent-consistency/Real-Time-LCM-ControlNet-Lora-SD1.5/static/img2img.html
deleted file mode 100644
index 1534cfd3f01334c96bc858ceae8357992b0ca4ae..0000000000000000000000000000000000000000
--- a/spaces/latent-consistency/Real-Time-LCM-ControlNet-Lora-SD1.5/static/img2img.html
+++ /dev/null
@@ -1,383 +0,0 @@
-<!doctype html>
-<html>
-
-<head>
-    <meta charset="UTF-8">
-    <title>Real-Time Latent Consistency Model</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <script
-        src="https://cdnjs.cloudflare.com/ajax/libs/iframe-resizer/4.3.1/iframeResizer.contentWindow.min.js"></script>
-    <script src="https://cdn.jsdelivr.net/npm/piexifjs@1.0.6/piexif.min.js"></script>
-    <script src="https://cdn.tailwindcss.com"></script>
-    <style type="text/tailwindcss">
-        .button {
-          @apply bg-gray-700 hover:bg-gray-800 text-white font-normal p-2 rounded disabled:bg-gray-300 dark:disabled:bg-gray-700 disabled:cursor-not-allowed dark:disabled:text-black
-        }
-    </style>
-    <script type="module">
-        const getValue = (id) => {
-            const el = document.querySelector(`${id}`)
-            if (el.type === "checkbox")
-                return el.checked;
-            return el.value;
-        }
-
-        const startBtn = document.querySelector("#start");
-        const stopBtn = document.querySelector("#stop");
-        const videoEl = document.querySelector("#webcam");
-        const imageEl = document.querySelector("#player");
-        const queueSizeEl = document.querySelector("#queue_size");
-        const errorEl = document.querySelector("#error");
-        const snapBtn = document.querySelector("#snap");
-        const webcamsEl = document.querySelector("#webcams");
-
-        function LCMLive(webcamVideo, liveImage) {
-            let websocket;
-
-            async function start() {
-                return new Promise((resolve, reject) => {
-                    const websocketURL = `${window.location.protocol === "https:" ? "wss" : "ws"
-                        }:${window.location.host}/ws`;
-
-                    const socket = new WebSocket(websocketURL);
-                    socket.onopen = () => {
-                        console.log("Connected to websocket");
-                    };
-                    socket.onclose = () => {
-                        console.log("Disconnected from websocket");
-                        stop();
-                        resolve({ "status": "disconnected" });
-                    };
-                    socket.onerror = (err) => {
-                        console.error(err);
-                        reject(err);
-                    };
-                    socket.onmessage = (event) => {
-                        const data = JSON.parse(event.data);
-                        switch (data.status) {
-                            case "success":
-                                break;
-                            case "start":
-                                const userId = data.userId;
-                                initVideoStream(userId);
-                                break;
-                            case "timeout":
-                                stop();
-                                resolve({ "status": "timeout" });
-                            case "error":
-                                stop();
-                                reject(data.message);
-
-                        }
-                    };
-                    websocket = socket;
-                })
-            }
-            function switchCamera() {
-                const constraints = {
-                    audio: false,
-                    video: { width: 1024, height: 1024, deviceId: mediaDevices[webcamsEl.value].deviceId }
-                };
-                navigator.mediaDevices
-                    .getUserMedia(constraints)
-                    .then((mediaStream) => {
-                        webcamVideo.removeEventListener("timeupdate", videoTimeUpdateHandler);
-                        webcamVideo.srcObject = mediaStream;
-                        webcamVideo.onloadedmetadata = () => {
-                            webcamVideo.play();
-                            webcamVideo.addEventListener("timeupdate", videoTimeUpdateHandler);
-                        };
-                    })
-                    .catch((err) => {
-                        console.error(`${err.name}: ${err.message}`);
-                    });
-            }
-
-            async function videoTimeUpdateHandler() {
-                const dimension = getValue("input[name=dimension]:checked");
-                const [WIDTH, HEIGHT] = JSON.parse(dimension);
-
-                const canvas = new OffscreenCanvas(WIDTH, HEIGHT);
-                const videoW = webcamVideo.videoWidth;
-                const videoH = webcamVideo.videoHeight;
-                const aspectRatio = WIDTH / HEIGHT;
-
-                const ctx = canvas.getContext("2d");
-                ctx.drawImage(webcamVideo, videoW / 2 - videoH * aspectRatio / 2, 0, videoH * aspectRatio, videoH, 0, 0, WIDTH, HEIGHT)
-                const blob = await canvas.convertToBlob({ type: "image/jpeg", quality: 1 });
-                websocket.send(blob);
-                websocket.send(JSON.stringify({
-                    "seed": getValue("#seed"),
-                    "prompt": getValue("#prompt"),
-                    "guidance_scale": getValue("#guidance-scale"),
-                    "strength": getValue("#strength"),
-                    "steps": getValue("#steps"),
-                    "lcm_steps": getValue("#lcm_steps"),
-                    "width": WIDTH,
-                    "height": HEIGHT,
-                }));
-            }
-            let mediaDevices = [];
-            async function initVideoStream(userId) {
-                liveImage.src = `/stream/${userId}`;
-                await navigator.mediaDevices.enumerateDevices()
-                    .then(devices => {
-                        const cameras = devices.filter(device => device.kind === 'videoinput');
-                        mediaDevices = cameras;
-                        webcamsEl.innerHTML = "";
-                        cameras.forEach((camera, index) => {
-                            const option = document.createElement("option");
-                            option.value = index;
-                            option.innerText = camera.label;
-                            webcamsEl.appendChild(option);
-                            option.selected = index === 0;
-                        });
-                        webcamsEl.addEventListener("change", switchCamera);
-                    })
-                    .catch(err => {
-                        console.error(err);
-                    });
-                const constraints = {
-                    audio: false,
-                    video: { width: 1024, height: 1024, deviceId: mediaDevices[0].deviceId }
-                };
-                navigator.mediaDevices
-                    .getUserMedia(constraints)
-                    .then((mediaStream) => {
-                        webcamVideo.srcObject = mediaStream;
-                        webcamVideo.onloadedmetadata = () => {
-                            webcamVideo.play();
-                            webcamVideo.addEventListener("timeupdate", videoTimeUpdateHandler);
-                        };
-                    })
-                    .catch((err) => {
-                        console.error(`${err.name}: ${err.message}`);
-                    });
-            }
-
-            async function stop() {
-                websocket.close();
-                navigator.mediaDevices.getUserMedia({ video: true }).then((mediaStream) => {
-                    mediaStream.getTracks().forEach((track) => track.stop());
-                });
-                webcamVideo.removeEventListener("timeupdate", videoTimeUpdateHandler);
-                webcamsEl.removeEventListener("change", switchCamera);
-                webcamVideo.srcObject = null;
-            }
-            return {
-                start,
-                stop
-            }
-        }
-        function toggleMessage(type) {
-            errorEl.hidden = false;
-            errorEl.scrollIntoView();
-            switch (type) {
-                case "error":
-                    errorEl.innerText = "To many users are using the same GPU, please try again later.";
-                    errorEl.classList.toggle("bg-red-300", "text-red-900");
-                    break;
-                case "success":
-                    errorEl.innerText = "Your session has ended, please start a new one.";
-                    errorEl.classList.toggle("bg-green-300", "text-green-900");
-                    break;
-            }
-            setTimeout(() => {
-                errorEl.hidden = true;
-            }, 2000);
-        }
-        function snapImage() {
-            try {
-                const zeroth = {};
-                const exif = {};
-                const gps = {};
-                zeroth[piexif.ImageIFD.Make] = "LCM Image-to-Image";
-                zeroth[piexif.ImageIFD.ImageDescription] = `prompt: ${getValue("#prompt")} | seed: ${getValue("#seed")} | guidance_scale: ${getValue("#guidance-scale")} | strength: ${getValue("#strength")} | lcm_steps: ${getValue("#lcm_steps")} | steps: ${getValue("#steps")}`;
-                zeroth[piexif.ImageIFD.Software] = "https://github.com/radames/Real-Time-Latent-Consistency-Model";
-
-                exif[piexif.ExifIFD.DateTimeOriginal] = new Date().toISOString();
-
-                const exifObj = { "0th": zeroth, "Exif": exif, "GPS": gps };
-                const exifBytes = piexif.dump(exifObj);
-
-                const canvas = document.createElement("canvas");
-                canvas.width = imageEl.naturalWidth;
-                canvas.height = imageEl.naturalHeight;
-                const ctx = canvas.getContext("2d");
-                ctx.drawImage(imageEl, 0, 0);
-                const dataURL = canvas.toDataURL("image/jpeg");
-                const withExif = piexif.insert(exifBytes, dataURL);
-
-                const a = document.createElement("a");
-                a.href = withExif;
-                a.download = `lcm_txt_2_img${Date.now()}.png`;
-                a.click();
-            } catch (err) {
-                console.log(err);
-            }
-        }
-
-
-        const lcmLive = LCMLive(videoEl, imageEl);
-        startBtn.addEventListener("click", async () => {
-            try {
-                startBtn.disabled = true;
-                snapBtn.disabled = false;
-                const res = await lcmLive.start();
-                startBtn.disabled = false;
-                if (res.status === "timeout")
-                    toggleMessage("success")
-            } catch (err) {
-                console.log(err);
-                toggleMessage("error")
-                startBtn.disabled = false;
-            }
-        });
-        stopBtn.addEventListener("click", () => {
-            lcmLive.stop();
-        });
-        window.addEventListener("beforeunload", () => {
-            lcmLive.stop();
-        });
-        snapBtn.addEventListener("click", snapImage);
-        setInterval(() =>
-            fetch("/queue_size")
-                .then((res) => res.json())
-                .then((data) => {
-                    queueSizeEl.innerText = data.queue_size;
-                })
-                .catch((err) => {
-                    console.log(err);
-                })
-            , 5000);
-    </script>
-</head>
-
-<body class="text-black dark:bg-gray-900 dark:text-white">
-    <div class="fixed right-2 top-2 p-4 font-bold text-sm rounded-lg max-w-xs text-center" id="error">
-    </div>
-    <main class="container mx-auto px-4 py-4 max-w-4xl flex flex-col gap-4">
-        <article class="text-center max-w-xl mx-auto">
-            <h1 class="text-3xl font-bold">Real-Time Latent Consistency Model</h1>
-            <h2 class="text-2xl font-bold mb-4">Image to Image</h2>
-            <p class="text-sm">
-                This demo showcases
-                <a href="https://huggingface.co/SimianLuo/LCM_Dreamshaper_v7" target="_blank"
-                    class="text-blue-500 underline hover:no-underline">LCM</a> Image to Image pipeline
-                using
-                <a href="https://github.com/huggingface/diffusers/tree/main/examples/community#latent-consistency-pipeline"
-                    target="_blank" class="text-blue-500 underline hover:no-underline">Diffusers</a> with a MJPEG
-                stream server.
-            </p>
-            <p class="text-sm">
-                There are <span id="queue_size" class="font-bold">0</span> user(s) sharing the same GPU, affecting
-                real-time performance. Maximum queue size is 4. <a
-                    href="https://huggingface.co/spaces/radames/Real-Time-Latent-Consistency-Model?duplicate=true"
-                    target="_blank" class="text-blue-500 underline hover:no-underline">Duplicate</a> and run it on your
-                own GPU.
-            </p>
-        </article>
-        <div>
-            <h2 class="font-medium">Prompt</h2>
-            <p class="text-sm text-gray-500">
-                Change the prompt to generate different images, accepts <a
-                    href="https://github.com/damian0815/compel/blob/main/doc/syntax.md" target="_blank"
-                    class="text-blue-500 underline hover:no-underline">Compel</a> syntax.
-            </p>
-            <div class="flex text-normal px-1 py-1 border border-gray-700 rounded-md items-center">
-                <textarea type="text" id="prompt" class="font-light w-full px-3 py-2 mx-1  outline-none dark:text-black"
-                    title="Prompt, this is an example, feel free to modify"
-                    placeholder="Add your prompt here...">Portrait of The Terminator with , glare pose, detailed, intricate, full of colour, cinematic lighting, trending on artstation, 8k, hyperrealistic, focused, extreme details, unreal engine 5, cinematic, masterpiece</textarea>
-            </div>
-
-        </div>
-        <div class="">
-            <details>
-                <summary class="font-medium cursor-pointer">Advanced Options</summary>
-                <div class="grid grid-cols-3 sm:grid-cols-6 items-center gap-3 py-3">
-                    <label for="webcams" class="text-sm font-medium">Camera Options: </label>
-                    <select id="webcams" class="text-sm border-2 border-gray-500 rounded-md font-light dark:text-black">
-                    </select>
-                    <div></div>
-                    <label class="text-sm font-medium " for="steps">Inference Steps
-                    </label>
-                    <input type="range" id="steps" name="steps" min="1" max="20" value="4"
-                        oninput="this.nextElementSibling.value = Number(this.value)">
-                    <output class="text-xs w-[50px] text-center font-light px-1 py-1 border border-gray-700 rounded-md">
-                        4</output>
-                    <!--  -->
-                    <label class="text-sm font-medium" for="lcm_steps">LCM Inference Steps
-                    </label>
-                    <input type="range" id="lcm_steps" name="lcm_steps" min="2" max="60" value="50"
-                        oninput="this.nextElementSibling.value = Number(this.value)">
-                    <output class="text-xs w-[50px] text-center font-light px-1 py-1 border border-gray-700 rounded-md">
-                        50</output>
-                    <!--  -->
-                    <label class="text-sm font-medium" for="guidance-scale">Guidance Scale
-                    </label>
-                    <input type="range" id="guidance-scale" name="guidance-scale" min="0" max="30" step="0.001"
-                        value="8.0" oninput="this.nextElementSibling.value = Number(this.value).toFixed(2)">
-                    <output class="text-xs w-[50px] text-center font-light px-1 py-1 border border-gray-700 rounded-md">
-                        8.0</output>
-                    <!--  -->
-                    <label class="text-sm font-medium" for="strength">Strength</label>
-                    <input type="range" id="strength" name="strength" min="0.1" max="1" step="0.001" value="0.50"
-                        oninput="this.nextElementSibling.value = Number(this.value).toFixed(2)">
-                    <output class="text-xs w-[50px] text-center font-light px-1 py-1 border border-gray-700 rounded-md">
-                        0.5</output>
-                    <!--  -->
-                    <label class="text-sm font-medium" for="seed">Seed</label>
-                    <input type="number" id="seed" name="seed" value="299792458"
-                        class="font-light border border-gray-700 text-right rounded-md p-2 dark:text-black">
-                    <button
-                        onclick="document.querySelector('#seed').value = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)"
-                        class="button">
-                        Rand
-                    </button>
-                    <!--  -->
-                    <!--  -->
-                    <label class="text-sm font-medium" for="dimension">Image Dimensions</label>
-                    <div class="col-span-2 flex gap-2">
-                        <div class="flex gap-1">
-                            <input type="radio" id="dimension512" name="dimension" value="[512,512]" checked
-                                class="cursor-pointer">
-                            <label for="dimension512" class="text-sm cursor-pointer">512x512</label>
-                        </div>
-                        <div class="flex gap-1">
-                            <input type="radio" id="dimension768" name="dimension" value="[768,768]"
-                                lass="cursor-pointer">
-                            <label for="dimension768" class="text-sm cursor-pointer">768x768</label>
-                        </div>
-                    </div>
-                    <!--  -->
-                </div>
-            </details>
-        </div>
-        <div class="flex gap-3">
-            <button id="start" class="button">
-                Start
-            </button>
-            <button id="stop" class="button">
-                Stop
-            </button>
-            <button id="snap" disabled class="button ml-auto">
-                Snapshot
-            </button>
-        </div>
-        <div class="relative rounded-lg border border-slate-300 overflow-hidden">
-            <img id="player" class="w-full aspect-square rounded-lg "
-                src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=">
-            <div class="absolute top-0 left-0 w-1/4 aspect-square">
-                <video id="webcam" class="w-full aspect-square relative z-10 object-cover" playsinline autoplay muted
-                    loop></video>
-                <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 448" width="100"
-                    class="w-full p-4 absolute top-0 opacity-20 z-0">
-                    <path fill="currentColor"
-                        d="M224 256a128 128 0 1 0 0-256 128 128 0 1 0 0 256zm-45.7 48A178.3 178.3 0 0 0 0 482.3 29.7 29.7 0 0 0 29.7 512h388.6a29.7 29.7 0 0 0 29.7-29.7c0-98.5-79.8-178.3-178.3-178.3h-91.4z" />
-                </svg>
-            </div>
-        </div>
-    </main>
-</body>
-
-</html>
\ No newline at end of file
diff --git a/spaces/lewiswu1209/MockingBird/encoder/model.py b/spaces/lewiswu1209/MockingBird/encoder/model.py
deleted file mode 100644
index e050d3204d8f1becdf0f8b3133470708e5420cea..0000000000000000000000000000000000000000
--- a/spaces/lewiswu1209/MockingBird/encoder/model.py
+++ /dev/null
@@ -1,135 +0,0 @@
-from encoder.params_model import *
-from encoder.params_data import *
-from scipy.interpolate import interp1d
-from sklearn.metrics import roc_curve
-from torch.nn.utils import clip_grad_norm_
-from scipy.optimize import brentq
-from torch import nn
-import numpy as np
-import torch
-
-
-class SpeakerEncoder(nn.Module):
-    def __init__(self, device, loss_device):
-        super().__init__()
-        self.loss_device = loss_device
-        
-        # Network defition
-        self.lstm = nn.LSTM(input_size=mel_n_channels,
-                            hidden_size=model_hidden_size, 
-                            num_layers=model_num_layers, 
-                            batch_first=True).to(device)
-        self.linear = nn.Linear(in_features=model_hidden_size, 
-                                out_features=model_embedding_size).to(device)
-        self.relu = torch.nn.ReLU().to(device)
-        
-        # Cosine similarity scaling (with fixed initial parameter values)
-        self.similarity_weight = nn.Parameter(torch.tensor([10.])).to(loss_device)
-        self.similarity_bias = nn.Parameter(torch.tensor([-5.])).to(loss_device)
-
-        # Loss
-        self.loss_fn = nn.CrossEntropyLoss().to(loss_device)
-        
-    def do_gradient_ops(self):
-        # Gradient scale
-        self.similarity_weight.grad *= 0.01
-        self.similarity_bias.grad *= 0.01
-            
-        # Gradient clipping
-        clip_grad_norm_(self.parameters(), 3, norm_type=2)
-    
-    def forward(self, utterances, hidden_init=None):
-        """
-        Computes the embeddings of a batch of utterance spectrograms.
-        
-        :param utterances: batch of mel-scale filterbanks of same duration as a tensor of shape 
-        (batch_size, n_frames, n_channels) 
-        :param hidden_init: initial hidden state of the LSTM as a tensor of shape (num_layers, 
-        batch_size, hidden_size). Will default to a tensor of zeros if None.
-        :return: the embeddings as a tensor of shape (batch_size, embedding_size)
-        """
-        # Pass the input through the LSTM layers and retrieve all outputs, the final hidden state
-        # and the final cell state.
-        out, (hidden, cell) = self.lstm(utterances, hidden_init)
-        
-        # We take only the hidden state of the last layer
-        embeds_raw = self.relu(self.linear(hidden[-1]))
-        
-        # L2-normalize it
-        embeds = embeds_raw / (torch.norm(embeds_raw, dim=1, keepdim=True) + 1e-5)        
-
-        return embeds
-    
-    def similarity_matrix(self, embeds):
-        """
-        Computes the similarity matrix according the section 2.1 of GE2E.
-
-        :param embeds: the embeddings as a tensor of shape (speakers_per_batch, 
-        utterances_per_speaker, embedding_size)
-        :return: the similarity matrix as a tensor of shape (speakers_per_batch,
-        utterances_per_speaker, speakers_per_batch)
-        """
-        speakers_per_batch, utterances_per_speaker = embeds.shape[:2]
-        
-        # Inclusive centroids (1 per speaker). Cloning is needed for reverse differentiation
-        centroids_incl = torch.mean(embeds, dim=1, keepdim=True)
-        centroids_incl = centroids_incl.clone() / (torch.norm(centroids_incl, dim=2, keepdim=True) + 1e-5)
-
-        # Exclusive centroids (1 per utterance)
-        centroids_excl = (torch.sum(embeds, dim=1, keepdim=True) - embeds)
-        centroids_excl /= (utterances_per_speaker - 1)
-        centroids_excl = centroids_excl.clone() / (torch.norm(centroids_excl, dim=2, keepdim=True) + 1e-5)
-
-        # Similarity matrix. The cosine similarity of already 2-normed vectors is simply the dot
-        # product of these vectors (which is just an element-wise multiplication reduced by a sum).
-        # We vectorize the computation for efficiency.
-        sim_matrix = torch.zeros(speakers_per_batch, utterances_per_speaker,
-                                 speakers_per_batch).to(self.loss_device)
-        mask_matrix = 1 - np.eye(speakers_per_batch, dtype=np.int)
-        for j in range(speakers_per_batch):
-            mask = np.where(mask_matrix[j])[0]
-            sim_matrix[mask, :, j] = (embeds[mask] * centroids_incl[j]).sum(dim=2)
-            sim_matrix[j, :, j] = (embeds[j] * centroids_excl[j]).sum(dim=1)
-        
-        ## Even more vectorized version (slower maybe because of transpose)
-        # sim_matrix2 = torch.zeros(speakers_per_batch, speakers_per_batch, utterances_per_speaker
-        #                           ).to(self.loss_device)
-        # eye = np.eye(speakers_per_batch, dtype=np.int)
-        # mask = np.where(1 - eye)
-        # sim_matrix2[mask] = (embeds[mask[0]] * centroids_incl[mask[1]]).sum(dim=2)
-        # mask = np.where(eye)
-        # sim_matrix2[mask] = (embeds * centroids_excl).sum(dim=2)
-        # sim_matrix2 = sim_matrix2.transpose(1, 2)
-        
-        sim_matrix = sim_matrix * self.similarity_weight + self.similarity_bias
-        return sim_matrix
-    
-    def loss(self, embeds):
-        """
-        Computes the softmax loss according the section 2.1 of GE2E.
-        
-        :param embeds: the embeddings as a tensor of shape (speakers_per_batch, 
-        utterances_per_speaker, embedding_size)
-        :return: the loss and the EER for this batch of embeddings.
-        """
-        speakers_per_batch, utterances_per_speaker = embeds.shape[:2]
-        
-        # Loss
-        sim_matrix = self.similarity_matrix(embeds)
-        sim_matrix = sim_matrix.reshape((speakers_per_batch * utterances_per_speaker, 
-                                         speakers_per_batch))
-        ground_truth = np.repeat(np.arange(speakers_per_batch), utterances_per_speaker)
-        target = torch.from_numpy(ground_truth).long().to(self.loss_device)
-        loss = self.loss_fn(sim_matrix, target)
-        
-        # EER (not backpropagated)
-        with torch.no_grad():
-            inv_argmax = lambda i: np.eye(1, speakers_per_batch, i, dtype=np.int)[0]
-            labels = np.array([inv_argmax(i) for i in ground_truth])
-            preds = sim_matrix.detach().cpu().numpy()
-
-            # Snippet from https://yangcha.github.io/EER-ROC/
-            fpr, tpr, thresholds = roc_curve(labels.flatten(), preds.flatten())           
-            eer = brentq(lambda x: 1. - x - interp1d(fpr, tpr)(x), 0., 1.)
-            
-        return loss, eer
diff --git a/spaces/lewiswu1209/MockingBird/mkgui/base/components/outputs.py b/spaces/lewiswu1209/MockingBird/mkgui/base/components/outputs.py
deleted file mode 100644
index f4859c64b9e21114436e57863fedd5fd161da627..0000000000000000000000000000000000000000
--- a/spaces/lewiswu1209/MockingBird/mkgui/base/components/outputs.py
+++ /dev/null
@@ -1,43 +0,0 @@
-from typing import List
-
-from pydantic import BaseModel
-
-
-class ScoredLabel(BaseModel):
-    label: str
-    score: float
-
-
-class ClassificationOutput(BaseModel):
-    __root__: List[ScoredLabel]
-
-    def __iter__(self):  # type: ignore
-        return iter(self.__root__)
-
-    def __getitem__(self, item):  # type: ignore
-        return self.__root__[item]
-
-    def render_output_ui(self, streamlit) -> None:  # type: ignore
-        import plotly.express as px
-
-        sorted_predictions = sorted(
-            [prediction.dict() for prediction in self.__root__],
-            key=lambda k: k["score"],
-        )
-
-        num_labels = len(sorted_predictions)
-        if len(sorted_predictions) > 10:
-            num_labels = streamlit.slider(
-                "Maximum labels to show: ",
-                min_value=1,
-                max_value=len(sorted_predictions),
-                value=len(sorted_predictions),
-            )
-        fig = px.bar(
-            sorted_predictions[len(sorted_predictions) - num_labels :],
-            x="score",
-            y="label",
-            orientation="h",
-        )
-        streamlit.plotly_chart(fig, use_container_width=True)
-        # fig.show()
diff --git a/spaces/lewiswu1209/MockingBird/ppg2mel/train/__init__.py b/spaces/lewiswu1209/MockingBird/ppg2mel/train/__init__.py
deleted file mode 100644
index 4287ca8617970fa8fc025b75cb319c7032706910..0000000000000000000000000000000000000000
--- a/spaces/lewiswu1209/MockingBird/ppg2mel/train/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-#
\ No newline at end of file
diff --git a/spaces/librarian-bots/recommend_similar_papers/app.py b/spaces/librarian-bots/recommend_similar_papers/app.py
deleted file mode 100644
index 683f877e6320feac409185367345eb7a889ebd46..0000000000000000000000000000000000000000
--- a/spaces/librarian-bots/recommend_similar_papers/app.py
+++ /dev/null
@@ -1,87 +0,0 @@
-import gradio as gr
-import requests
-from cachetools import cached, TTLCache
-
-CACHE_TIME = 60 * 60 * 6  # 6 hours
-
-
-def parse_arxiv_id_from_paper_url(url):
-    return url.split("/")[-1]
-
-
-@cached(cache=TTLCache(maxsize=500, ttl=CACHE_TIME))
-def get_recommendations_from_semantic_scholar(semantic_scholar_id: str):
-    try:
-        r = requests.post(
-            "https://api.semanticscholar.org/recommendations/v1/papers/",
-            json={
-                "positivePaperIds": [semantic_scholar_id],
-            },
-            params={"fields": "externalIds,title,year", "limit": 10},
-        )
-        return r.json()["recommendedPapers"]
-    except KeyError as e:
-        raise gr.Error(
-            "Error getting recommendations, if this is a new paper it may not yet have"
-            " been indexed by Semantic Scholar."
-        ) from e
-
-
-def filter_recommendations(recommendations, max_paper_count=5):
-    # include only arxiv papers
-    arxiv_paper = [
-        r for r in recommendations if r["externalIds"].get("ArXiv", None) is not None
-    ]
-    if len(arxiv_paper) > max_paper_count:
-        arxiv_paper = arxiv_paper[:max_paper_count]
-    return arxiv_paper
-
-
-@cached(cache=TTLCache(maxsize=500, ttl=CACHE_TIME))
-def get_paper_title_from_arxiv_id(arxiv_id):
-    try:
-        return requests.get(f"https://huggingface.co/api/papers/{arxiv_id}").json()[
-            "title"
-        ]
-    except Exception as e:
-        print(f"Error getting paper title for {arxiv_id}: {e}")
-        raise gr.Error("Error getting paper title for {arxiv_id}: {e}") from e
-
-
-def format_recommendation_into_markdown(arxiv_id, recommendations):
-    # title = get_paper_title_from_arxiv_id(arxiv_id)
-    # url = f"https://huggingface.co/papers/{arxiv_id}"
-    # comment = f"Recommended papers for [{title}]({url})\n\n"
-    comment = "The following papers were recommended by the Semantic Scholar API \n\n"
-    for r in recommendations:
-        hub_paper_url = f"https://huggingface.co/papers/{r['externalIds']['ArXiv']}"
-        comment += f"* [{r['title']}]({hub_paper_url}) ({r['year']})\n"
-    return comment
-
-
-def return_recommendations(url):
-    arxiv_id = parse_arxiv_id_from_paper_url(url)
-    recommendations = get_recommendations_from_semantic_scholar(f"ArXiv:{arxiv_id}")
-    filtered_recommendations = filter_recommendations(recommendations)
-    return format_recommendation_into_markdown(arxiv_id, filtered_recommendations)
-
-
-title = "Semantic Scholar Paper Recommender"
-description = (
-    "Paste a link to a paper on Hugging Face Papers and get recommendations for similar"
-    " papers from Semantic Scholar.**Note**: Some papers may not have recommendations"
-    " yet if they are new or have not been indexed by Semantic Scholar."
-)
-examples = [
-    "https://huggingface.co/papers/2309.12307",
-    "https://huggingface.co/papers/2211.10086",
-]
-interface = gr.Interface(
-    return_recommendations,
-    gr.Textbox(lines=1),
-    gr.Markdown(),
-    examples=examples,
-    title=title,
-    description=description,
-)
-interface.launch()
diff --git a/spaces/liminghao1630/TrOCR-printed/README.md b/spaces/liminghao1630/TrOCR-printed/README.md
deleted file mode 100644
index 7ef70ea568e657bd9d2fc7a634de8e8d7c6855ac..0000000000000000000000000000000000000000
--- a/spaces/liminghao1630/TrOCR-printed/README.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: TrOCR Printed
-emoji: 🦀
-colorFrom: green
-colorTo: yellow
-sdk: gradio
-app_file: app.py
-pinned: false
----
-
-# Configuration
-
-`title`: _string_  
-Display title for the Space
-
-`emoji`: _string_  
-Space emoji (emoji-only character allowed)
-
-`colorFrom`: _string_  
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`colorTo`: _string_  
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`sdk`: _string_  
-Can be either `gradio` or `streamlit`
-
-`sdk_version` : _string_  
-Only applicable for `streamlit` SDK.  
-See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions.
-
-`app_file`: _string_  
-Path to your main application file (which contains either `gradio` or `streamlit` Python code).  
-Path is relative to the root of the repository.
-
-`pinned`: _boolean_  
-Whether the Space stays on top of your list.
diff --git a/spaces/lincquiQcaudo/Top-20-Diffusion/Autopol Download Torrent Crack Full.md b/spaces/lincquiQcaudo/Top-20-Diffusion/Autopol Download Torrent Crack Full.md
deleted file mode 100644
index 21ddd8e3fcdc6bff3382e4d448618d9ea8bf2fe3..0000000000000000000000000000000000000000
--- a/spaces/lincquiQcaudo/Top-20-Diffusion/Autopol Download Torrent Crack Full.md	
+++ /dev/null
@@ -1,14 +0,0 @@
-<h2>Autopol Download Torrent Crack Full</h2><br /><p><b><b>Download File</b> ->->->-> <a href="https://bytlly.com/2uGxQh">https://bytlly.com/2uGxQh</a></b></p><br /><br />
-
-Advanced technology is now available for professionals who require to program and lay out complex parts to fulfill the needs of their customers. The AutoPOL software is designed to make these tasks easier for every press brake operator. The AutoPOL system includes a non-contact optical technology that is capable of measuring and laying out straight or deformed parts in millimeter or hundredths of millimeter precision. The AutoPOL system is an easy to use software application designed to quickly and accurately unfold and program a 3D CAD model of your new part or tool for use on a 3D printing or manual metal forming press. The AutoPOL system will import the parts from a CAD or CAE software package and make it easy to unfold the part using your own equipment. Using AutoPOL will quickly and accurately solve many of the time-consuming and costly problems of designing tooling for metal forming and other operations. The AutoPOL system is quick, accurate, easy to use and eliminates the need to set up and calibrate the software each time you need to use it.
-
-The AutoPOL system is very easy to use. As you add features to the system (which may be done through the Internet, the CD-ROM or the hard drive) the complexity of the operation is increased. This is a very user-friendly system. As soon as you turn on the machine it is ready to use. To start AutoPOL, point the software at your source file, which is most likely a 3D CAD file. The software then expands the file into a programming grid that enables you to easily unfold the part and accurately use it on the press. The AutoPOL system is not a "one-use only" software application. You can save your designs and models in the software and then transfer them to a 3D printing machine or to a manual metal forming press. The software can also be used to export a 3D part to a format suitable for CAD, CAE, or CAM applications.
-
-The software is compatible with most 3D CAD and CAE packages and some CAM packages. You can import most non-stacked solid modeling packages. The software can import and export most solid modeling packages.
-
-The AutoPOL system includes a VB-based workspace that is fully configurable. With the use of a mouse, keyboard or touch-screen the user can navigate the workspace to define the part and deformation of the part.
-
-As AutoPOL unfolds the parts, a large viewing area is provided on the screen to easily work with the part 4fefd39f24<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/lint/anime_controlnet/quickstart_train.py b/spaces/lint/anime_controlnet/quickstart_train.py
deleted file mode 100644
index 2480dc7d0711d107a384bbbb3b77af193337414a..0000000000000000000000000000000000000000
--- a/spaces/lint/anime_controlnet/quickstart_train.py
+++ /dev/null
@@ -1,50 +0,0 @@
-
-from argparse import Namespace
-from multiprocessing import cpu_count
-from src.lab import Lab
-
-# runs on 10GB VRAM GPU (RTX 3080)
-args = Namespace(
-    
-    pretrained_model_name_or_path="lint/liquidfix",
-    controlnet_weights_path="lint/anime_control/anime_merge",
-    #controlnet_weights_path=None, #
-    vae_path="lint/anime_vae",
-
-    # dataset args
-    train_data_dir="lint/anybooru",
-    valid_data_dir="",
-    resolution=512,
-    from_hf_hub=True,
-    controlnet_hint_key="canny", # set this to "canny" to train with canny hint, or None to pass
-
-    # training args
-    # options are ["zero convolutions", "input hint blocks"], otherwise trains whole controlnet
-    training_stage = "",
-    learning_rate=5e-6,
-    num_train_epochs=1000,
-    max_train_steps=None,
-    seed=3434554,
-    max_grad_norm=1.0,
-    gradient_accumulation_steps=1,
-
-    # VRAM args
-    batch_size=1,
-    mixed_precision="fp16", # set to "fp16" for mixed-precision training.
-    gradient_checkpointing=True, # set this to True to lower the memory usage.
-    use_8bit_adam=True, # use 8bit optimizer from bitsandbytes
-    enable_xformers_memory_efficient_attention=True,
-    allow_tf32=True,
-    dataloader_num_workers=cpu_count(),
-
-    # logging args
-    output_dir="./models",
-    report_to='tensorboard',
-    image_logging_steps=600, # disabled when 0. costs additional VRAM to log images
-    save_whole_pipeline=True,
-    checkpointing_steps=6000, 
-)
-
-if __name__ == '__main__':
-    lab = Lab(args)
-    lab.train(args.num_train_epochs)
diff --git a/spaces/luisotorres/Volatility-Based-Support-and-Resistance-Levels/app.py b/spaces/luisotorres/Volatility-Based-Support-and-Resistance-Levels/app.py
deleted file mode 100644
index 5650db469c6c97a598c010baf17804e3a9c2cd7e..0000000000000000000000000000000000000000
--- a/spaces/luisotorres/Volatility-Based-Support-and-Resistance-Levels/app.py
+++ /dev/null
@@ -1,141 +0,0 @@
-import yfinance as yf
-import numpy as np
-import pandas as pd
-import plotly.graph_objs as go
-import gradio as gr
-
-def plot_volatility_bands(ticker, reference_year):
-    
-    # Retrieving historical data and performing some preprocessing
-    df = yf.download(ticker)
-    df['Returns'] = df['Adj Close'].pct_change(1)
-    df['Adj Low'] = df['Low'] - (df['Close'] - df['Adj Close'])
-    df['Adj High'] = df['High'] - (df['Close'] - df['Adj Close'])
-    df['Adj Open'] = df['Open'] - (df['Close'] - df['Adj Close'])
-    df = df.fillna(0)
-    
-    # Obtaining the annualized volatility
-    T = 20
-    df['Annualized_Vol'] = np.round(df['Returns'].rolling(T).std()*np.sqrt(252), 2)
-    
-    # Calculating Bands
-    High_Band_1std = df.loc[reference_year]["Annualized_Vol"][-1]*df.loc[reference_year]["Adj Close"][-1] + df.loc[reference_year]["Adj Close"][-1]
-    Low_Band_1std = df.loc[reference_year]["Adj Close"][-1] - df.loc[reference_year]["Annualized_Vol"][-1]*df.loc[reference_year]["Adj Close"][-1]
-    High_Band_2std =  2*df.loc[reference_year]["Annualized_Vol"][-1]*df.loc[reference_year]["Adj Close"][-1] + df.loc[reference_year]["Adj Close"][-1]
-    Low_Band_2std =  df.loc[reference_year]["Adj Close"][-1] - 2*df.loc[reference_year]["Annualized_Vol"][-1]*df.loc[reference_year]["Adj Close"][-1]
-    High_Band_3std =  3*df.loc[reference_year]["Annualized_Vol"][-1]*df.loc[reference_year]["Adj Close"][-1] + df.loc[reference_year]["Adj Close"][-1]
-    Low_Band_3std =  df.loc[reference_year]["Adj Close"][-1] - 3*df.loc[reference_year]["Annualized_Vol"][-1]*df.loc[reference_year]["Adj Close"][-1]
-
-    
-    # Creating Candlestick chart
-    candlestick = go.Candlestick(x = df.loc[str(int(reference_year) + 1)].index,
-                             open = df.loc[str(int(reference_year) + 1)]['Adj Open'],
-                             high = df.loc[str(int(reference_year) + 1)]['Adj High'],
-                             low = df.loc[str(int(reference_year) + 1)]['Adj Low'],
-                             close = df.loc[str(int(reference_year) + 1)]['Adj Close'],
-                             increasing = dict(line=dict(color = 'red')),
-                             decreasing = dict(line=dict(color = 'black')),
-                             name = 'Candlesticks')
-
-
-    # Defining layout
-    layout = go.Layout(title = {'text': f'<b>Volatility-Based Supply and Demand Levels ({ticker})<br><br><sup>&nbsp;&nbsp;&nbsp;&nbsp;<i>Yearly Forecast - {str(int(reference_year) + 1)}</i></sup></b>',
-                                'x': .035, 'xanchor': 'left'},
-                       yaxis = dict(title = '<b>Price (USD)</b>',
-                                   tickfont=dict(size=16)),
-                       xaxis = dict(title = '<b>Date</b>'),
-                       template = 'seaborn',
-                       plot_bgcolor = '#F6F5F5',
-                       paper_bgcolor = '#F6F5F5',
-                       height = 450, width = 650,
-                       showlegend=False,
-                       xaxis_rangeslider_visible = False)
-
-    fig = go.Figure(data = [candlestick], layout = layout)
-    
-    # Fixing the empty spaces in the X-Axis
-    dt_all = pd.date_range(start = df.index[0]
-                           , end = df.index[-1]
-                           , freq = "D")
-    dt_all_py = [d.to_pydatetime() for d in dt_all]
-    dt_obs_py = [d.to_pydatetime() for d in df.index]
-
-    dt_breaks = [d for d in dt_all_py if d not in dt_obs_py]
-
-    fig.update_xaxes(
-        rangebreaks = [dict(values = dt_breaks)]
-    )
-
-    # 1σ
-    fig.add_hline(y = High_Band_1std, line_width = 2, line_dash = "dot", line_color = "green")
-    fig.add_hline(y = Low_Band_1std, line_width = 2, line_dash = "dot", line_color = "red")
-
-    # 2σ
-    fig.add_hline(y = High_Band_2std, line_width = 4, line_dash = "dash", line_color = "green")
-    fig.add_hline(y = Low_Band_2std, line_width = 4, line_dash = "dash", line_color = "red")
-
-    # 3σ
-    fig.add_hline(y = High_Band_3std, line_width = 6, line_dash = "dashdot", line_color = "green")
-    fig.add_hline(y = Low_Band_3std, line_width = 6, line_dash = "dashdot", line_color = "red")
-
-    fig.show()
-    
-    # Printing Supply and Demand Levels
-    print(f"\nVolatility-Based Supply and Demand Levels for {ticker} in {int(reference_year) + 1}\n")
-    print(f"Supply Level 3σ: {High_Band_3std.round(2)}\n")
-    print(f"Supply Level 2σ: {High_Band_2std.round(2)}\n")
-    print(f"Supply Level 1σ: {High_Band_1std.round(2)}\n")
-    print('-' * 165, '\n')
-    print(f"Demand Level 1σ: {Low_Band_1std.round(2)}\n")
-    print(f"Demand Level 2σ: {Low_Band_2std.round(2)}\n")
-    print(f"Demand Level 3σ: {Low_Band_3std.round(2)}\n")
-    
-    
-    # Creating the text output
-    text_info = f"""
-    Volatility-Based Supply and Demand Levels for {ticker} in {int(reference_year) + 1}\n
-    Supply Level 3σ: {High_Band_3std.round(2)}\n
-    Supply Level 2σ: {High_Band_2std.round(2)}\n
-    Supply Level 1σ: {High_Band_1std.round(2)}\n
-    -------------------------\n
-    Demand Level 1σ: {Low_Band_1std.round(2)}\n
-    Demand Level 2σ: {Low_Band_2std.round(2)}\n
-    Demand Level 3σ: {Low_Band_3std.round(2)}\n
-    """
-    
-    return fig, text_info
-
-def wrapper_func(ticker, reference_year):
-    try:
-        fig, text_info = plot_volatility_bands(ticker, str(int(reference_year)))  
-        return fig, text_info
-    except Exception as e:
-        error_message = str(e)
-        return error_message, error_message
-
-iface = gr.Interface(
-    title = '📈 Volatility-Based Supply and Demand Levels 📉',
-    description="""<br> The ideas presented in this app are based on the research paper <a href = "https://www.outspokenmarket.com/uploads/8/8/2/3/88233040/supply_and_demand_levels_forecasting_based_on_returns_volatility.pdf">Supply and Demand Levels Forecasting Based on Returns Volatility</a>,authored by <a href = "https://www.outspokenmarket.com/">Leandro Guerra</a>. <br>
-                In the Kaggle Notebook, <a href = "https://www.kaggle.com/code/lusfernandotorres/volatility-based-supply-and-demand-levels/notebook">Volatility-Based Supply & Demand Levels Forecasting</a>, you can read further on how these supply and demand levels are calculated. <br><br>
-                <b>Intructions</b><br>
-                Enter the ticker of a security as it is displayed on Yahoo Finance. Then inform a year of reference. <br>
-                The supply and demand levels are forecastings for the following year. If you inform <i>2022</i> as input, the plot will contain the forecastings for <i>2023</i>. <br><br>
-                
-                • Dot lines represent one standard deviation (68.7% probability). <br>
-
-                • Dash lines represent two standard deviations (95.4% probability). <br>
-
-                • Dash and dot lines represent three standard deviations (99.7% probability).""",
-    fn=wrapper_func,
-    inputs=[
-        gr.Textbox(label="Enter the Ticker as it Appears on Yahoo Finance"),
-        gr.Number(label="Enter the Year of Reference")
-    ],
-    outputs=[
-        gr.Plot(label = ""),
-        gr.Textbox(label = "")
-    ],
-    css=".gr-input {width: 60px;}"
-)
-
-iface.launch()
diff --git a/spaces/lunarflu/HF-QA-Demo-3/discord_bot/client/client.py b/spaces/lunarflu/HF-QA-Demo-3/discord_bot/client/client.py
deleted file mode 100644
index e3d651e662a706733e0ea0ec614bc2e0ca543770..0000000000000000000000000000000000000000
--- a/spaces/lunarflu/HF-QA-Demo-3/discord_bot/client/client.py
+++ /dev/null
@@ -1,130 +0,0 @@
-import json
-import requests
-from urllib.parse import quote
-import discord
-from typing import List
-
-from qa_engine import logger, QAEngine
-from discord_bot.client.utils import split_text_into_chunks
-
-
-class DiscordClient(discord.Client):
-    """
-    Discord Client class, used for interacting with a Discord server.
-
-    Args:
-        qa_service_url (str): The URL of the question answering service.
-        num_last_messages (int, optional): The number of previous messages to use as context for generating answers.
-        Defaults to 5.
-        use_names_in_context (bool, optional): Whether to include user names in the message context. Defaults to True.
-        enable_commands (bool, optional): Whether to enable commands for the bot. Defaults to True.
-
-    Attributes:
-        qa_service_url (str): The URL of the question answering service.
-        num_last_messages (int): The number of previous messages to use as context for generating answers.
-        use_names_in_context (bool): Whether to include user names in the message context.
-        enable_commands (bool): Whether to enable commands for the bot.
-        max_message_len (int): The maximum length of a message.
-        system_prompt (str): The system prompt to be used.
-
-    """
-    def __init__(
-        self,
-        qa_engine: QAEngine,
-        num_last_messages: int = 5,
-        use_names_in_context: bool = True,
-        enable_commands: bool = True,
-        debug: bool = False
-    ):
-        logger.info('Initializing Discord client...')
-        intents = discord.Intents.all()
-        intents.message_content = True
-        super().__init__(intents=intents, command_prefix='!')
-
-        assert num_last_messages >= 1, \
-            'The number of last messages in context should be at least 1'
-
-        self.qa_engine: QAEngine = qa_engine
-        self.num_last_messages: int = num_last_messages
-        self.use_names_in_context: bool = use_names_in_context
-        self.enable_commands: bool = enable_commands
-        self.debug: bool = debug
-        self.min_messgae_len: int = 1800
-        self.max_message_len: int = 2000
-
-
-    async def on_ready(self):
-        """
-        Callback function to be called when the client is ready.
-        """
-        logger.info('Successfully logged in as: {0.user}'.format(self))
-        await self.change_presence(activity=discord.Game(name='Chatting...'))
-
-
-    async def get_last_messages(self, message) -> List[str]:
-        """
-        Method to fetch recent messages from a message's channel.
-
-        Args:
-            message (Message): The discord Message object used to identify the channel.
-
-        Returns:
-            List[str]: Reversed list of recent messages from the channel,
-            excluding the input message. Messages may be prefixed with the author's name 
-            if `self.use_names_in_context` is True.
-        """
-        last_messages: List[str] = []
-        async for msg in message.channel.history(
-            limit=self.num_last_messages):
-            if self.use_names_in_context:
-                last_messages.append(f'{msg.author}: {msg.content}')
-            else:
-                last_messages.append(msg.content)
-        last_messages.reverse()
-        last_messages.pop() # remove last message from context
-        return last_messages
-
-
-    async def send_message(self, message, answer: str, sources: str):
-        chunks = split_text_into_chunks(
-            text=answer,
-            split_characters=['. ', ', ', '\n'],
-            min_size=self.min_messgae_len,
-            max_size=self.max_message_len
-        )
-        for chunk in chunks:
-            await message.channel.send(chunk)
-        await message.channel.send(sources)
-
-
-    async def on_message(self, message):
-        """
-        Callback function to be called when a message is received.
-
-        Args:
-            message (discord.Message): The received message.
-        """
-        if message.author == self.user:
-            return
-        if self.enable_commands and message.content.startswith('!'):
-            if message.content == '!clear':
-                await message.channel.purge()
-                return
-
-        last_messages = await self.get_last_messages(message)
-        context = '\n'.join(last_messages)
-
-        logger.info('Received message: {0.content}'.format(message))
-        response = self.qa_engine.get_response(
-            question=message.content,
-            messages_context=context
-        )
-        logger.info('Sending response: {0}'.format(response))
-        try:
-            await self.send_message(
-                message,
-                response.get_answer(),
-                response.get_sources_as_text()
-            )
-        except Exception as e:
-            logger.error('Failed to send response: {0}'.format(e))
diff --git a/spaces/ma-xu/LIVE/pybind11/include/pybind11/detail/typeid.h b/spaces/ma-xu/LIVE/pybind11/include/pybind11/detail/typeid.h
deleted file mode 100644
index 148889ffefdcc4de303d99f82af43aa9302c0a7c..0000000000000000000000000000000000000000
--- a/spaces/ma-xu/LIVE/pybind11/include/pybind11/detail/typeid.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-    pybind11/detail/typeid.h: Compiler-independent access to type identifiers
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <cstdio>
-#include <cstdlib>
-
-#if defined(__GNUG__)
-#include <cxxabi.h>
-#endif
-
-#include "common.h"
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-/// Erase all occurrences of a substring
-inline void erase_all(std::string &string, const std::string &search) {
-    for (size_t pos = 0;;) {
-        pos = string.find(search, pos);
-        if (pos == std::string::npos) break;
-        string.erase(pos, search.length());
-    }
-}
-
-PYBIND11_NOINLINE inline void clean_type_id(std::string &name) {
-#if defined(__GNUG__)
-    int status = 0;
-    std::unique_ptr<char, void (*)(void *)> res {
-        abi::__cxa_demangle(name.c_str(), nullptr, nullptr, &status), std::free };
-    if (status == 0)
-        name = res.get();
-#else
-    detail::erase_all(name, "class ");
-    detail::erase_all(name, "struct ");
-    detail::erase_all(name, "enum ");
-#endif
-    detail::erase_all(name, "pybind11::");
-}
-PYBIND11_NAMESPACE_END(detail)
-
-/// Return a string representation of a C++ type
-template <typename T> static std::string type_id() {
-    std::string name(typeid(T).name());
-    detail::clean_type_id(name);
-    return name;
-}
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/spaces/ma-xu/LIVE/thrust/thrust/system/cuda/detail/for_each.h b/spaces/ma-xu/LIVE/thrust/thrust/system/cuda/detail/for_each.h
deleted file mode 100644
index 542dcf754e752866324d38b630364a8d44a7b75f..0000000000000000000000000000000000000000
--- a/spaces/ma-xu/LIVE/thrust/thrust/system/cuda/detail/for_each.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/******************************************************************************
- * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION 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.
- *
- ******************************************************************************/
-#pragma once
-
-
-#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
-#include <iterator>
-#include <thrust/system/cuda/config.h>
-
-#include <thrust/system/cuda/detail/util.h>
-#include <thrust/system/cuda/detail/parallel_for.h>
-#include <thrust/detail/function.h>
-#include <thrust/distance.h>
-
-namespace thrust
-{
-
-namespace cuda_cub {
-
-  // for_each functor
-  template <class Input, class UnaryOp>
-  struct for_each_f
-  {
-    Input input;
-    UnaryOp op;
-
-    THRUST_FUNCTION
-    for_each_f(Input input, UnaryOp op)
-        : input(input), op(op) {}
-
-    template <class Size>
-    THRUST_DEVICE_FUNCTION void operator()(Size idx)
-    {
-      op(raw_reference_cast(input[idx]));
-    }
-  };
-
-  //-------------------------
-  // Thrust API entry points
-  //-------------------------
-
-  // for_each_n
-  template <class Derived,
-            class Input,
-            class Size,
-            class UnaryOp>
-  Input THRUST_FUNCTION
-  for_each_n(execution_policy<Derived> &policy,
-             Input                      first,
-             Size                       count,
-             UnaryOp                    op)
-  {
-    typedef thrust::detail::wrapped_function<UnaryOp, void> wrapped_t;
-    wrapped_t wrapped_op(op);
-
-    cuda_cub::parallel_for(policy,
-                           for_each_f<Input, wrapped_t>(first, wrapped_op),
-                           count);
-
-    cuda_cub::throw_on_error(
-      cuda_cub::synchronize(policy)
-    , "for_each: failed to synchronize"
-    );
-
-    return first + count;
-  }
-
-  // for_each
-  template <class Derived,
-            class Input,
-            class UnaryOp>
-  Input THRUST_FUNCTION
-  for_each(execution_policy<Derived> &policy,
-           Input                      first,
-           Input                      last,
-           UnaryOp                    op)
-  {
-    typedef typename iterator_traits<Input>::difference_type size_type;
-    size_type count = static_cast<size_type>(thrust::distance(first,last));
-    return cuda_cub::for_each_n(policy, first,  count, op);
-  }
-}    // namespace cuda_cub
-
-} // end namespace thrust
-#endif
diff --git a/spaces/mano96/content_rewrite/app.py b/spaces/mano96/content_rewrite/app.py
deleted file mode 100644
index 5efd2f6c14eb1d38c5415ea919ba2dfb0dec9caa..0000000000000000000000000000000000000000
--- a/spaces/mano96/content_rewrite/app.py
+++ /dev/null
@@ -1,44 +0,0 @@
-from newspaper import Article
-
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-
-tokenizer = AutoTokenizer.from_pretrained("Vamsi/T5_Paraphrase_Paws")
-model = AutoModelForSeq2SeqLM.from_pretrained("Vamsi/T5_Paraphrase_Paws")
-
-import nltk
-nltk.download('punkt')
-from nltk.tokenize import sent_tokenize
-
-def my_paraphrase(sentence):
-
-  sentence = "paraphrase: " + sentence + " </s>"
-  encoding = tokenizer.encode_plus(sentence,padding=True, return_tensors="pt")
-  input_ids, attention_masks = encoding["input_ids"], encoding["attention_mask"]
-  
-  outputs = model.generate(
-    input_ids=input_ids, attention_mask=attention_masks,
-    max_length=256,
-    do_sample=True,
-    top_k=120,
-    top_p=0.95,
-    early_stopping=True,
-    num_return_sequences=1)
-  output = tokenizer.decode(outputs[0], skip_special_tokens=True,clean_up_tokenization_spaces=True)
-
-  return(output)
-
-def text(input_text):
- 
-  output = " ".join([my_paraphrase(sent) for sent in sent_tokenize(input_text)])
-
-  return output
-
-import gradio as gr
-def summarize(Input_Text):
-
-  outputtext = text(Input_Text)
-  return outputtext
-gr.Interface(fn=summarize, inputs=gr.inputs.Textbox(lines=7, placeholder="Enter text here"), css="""span.svelte-1l2rj76{color: #591fc9;font-size: 18px;
-    font-weight: 600;}.secondary.svelte-1ma3u5b{background: #591fc9; color: #fff;}.secondary.svelte-1ma3u5b:hover{background:#8a59e8;color:#000;}
-    .svelte-2xzfnp textarea {border: 1px solid #591fc9}.primary.svelte-1ma3u5b{background: #f8d605;color: #000;}.primary.svelte-1ma3u5b:hover{background: #ffe751;color: #591fc9;}.svelte-2xzfnp{height: 168px !important;}.svelte-1iguv9h {max-width: none !important; margin: 0px !important; padding: 0px !important;} label.svelte-2xzfnp{display: contents !important;}  """, outputs=[gr.outputs.Textbox(label="Paraphrased Text")],examples=[["developed by python team"
-]]).launch(inline=False)
\ No newline at end of file
diff --git a/spaces/matthoffner/AudioCraft_Plus/tests/__init__.py b/spaces/matthoffner/AudioCraft_Plus/tests/__init__.py
deleted file mode 100644
index 0952fcc3f57e34b3747962e9ebd6fc57aeea63fa..0000000000000000000000000000000000000000
--- a/spaces/matthoffner/AudioCraft_Plus/tests/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
diff --git a/spaces/matthoffner/chatbot-mini/components/Promptbar/components/PromptbarSettings.tsx b/spaces/matthoffner/chatbot-mini/components/Promptbar/components/PromptbarSettings.tsx
deleted file mode 100644
index 5fad6f9ca3d08ccb3ce1cdaf53d23632534a1632..0000000000000000000000000000000000000000
--- a/spaces/matthoffner/chatbot-mini/components/Promptbar/components/PromptbarSettings.tsx
+++ /dev/null
@@ -1,7 +0,0 @@
-import { FC } from 'react';
-
-interface Props {}
-
-export const PromptbarSettings: FC<Props> = () => {
-  return <div></div>;
-};
diff --git a/spaces/matthoffner/starchat-ui/components/Chat/VariableModal.tsx b/spaces/matthoffner/starchat-ui/components/Chat/VariableModal.tsx
deleted file mode 100644
index 6a644d4332744b3ea36659e0600adaee4aa2d820..0000000000000000000000000000000000000000
--- a/spaces/matthoffner/starchat-ui/components/Chat/VariableModal.tsx
+++ /dev/null
@@ -1,124 +0,0 @@
-import { FC, KeyboardEvent, useEffect, useRef, useState } from 'react';
-
-import { Prompt } from '@/types/prompt';
-
-interface Props {
-  prompt: Prompt;
-  variables: string[];
-  onSubmit: (updatedVariables: string[]) => void;
-  onClose: () => void;
-}
-
-export const VariableModal: FC<Props> = ({
-  prompt,
-  variables,
-  onSubmit,
-  onClose,
-}) => {
-  const [updatedVariables, setUpdatedVariables] = useState<
-    { key: string; value: string }[]
-  >(
-    variables
-      .map((variable) => ({ key: variable, value: '' }))
-      .filter(
-        (item, index, array) =>
-          array.findIndex((t) => t.key === item.key) === index,
-      ),
-  );
-
-  const modalRef = useRef<HTMLDivElement>(null);
-  const nameInputRef = useRef<HTMLTextAreaElement>(null);
-
-  const handleChange = (index: number, value: string) => {
-    setUpdatedVariables((prev) => {
-      const updated = [...prev];
-      updated[index].value = value;
-      return updated;
-    });
-  };
-
-  const handleSubmit = () => {
-    if (updatedVariables.some((variable) => variable.value === '')) {
-      alert('Please fill out all variables');
-      return;
-    }
-
-    onSubmit(updatedVariables.map((variable) => variable.value));
-    onClose();
-  };
-
-  const handleKeyDown = (e: KeyboardEvent<HTMLDivElement>) => {
-    if (e.key === 'Enter' && !e.shiftKey) {
-      e.preventDefault();
-      handleSubmit();
-    } else if (e.key === 'Escape') {
-      onClose();
-    }
-  };
-
-  useEffect(() => {
-    const handleOutsideClick = (e: MouseEvent) => {
-      if (modalRef.current && !modalRef.current.contains(e.target as Node)) {
-        onClose();
-      }
-    };
-
-    window.addEventListener('click', handleOutsideClick);
-
-    return () => {
-      window.removeEventListener('click', handleOutsideClick);
-    };
-  }, [onClose]);
-
-  useEffect(() => {
-    if (nameInputRef.current) {
-      nameInputRef.current.focus();
-    }
-  }, []);
-
-  return (
-    <div
-      className="fixed inset-0 z-50 flex items-center justify-center bg-black bg-opacity-50"
-      onKeyDown={handleKeyDown}
-    >
-      <div
-        ref={modalRef}
-        className="dark:border-netural-400 inline-block max-h-[400px] transform overflow-y-auto rounded-lg border border-gray-300 bg-white px-4 pt-5 pb-4 text-left align-bottom shadow-xl transition-all dark:bg-[#202123] sm:my-8 sm:max-h-[600px] sm:w-full sm:max-w-lg sm:p-6 sm:align-middle"
-        role="dialog"
-      >
-        <div className="mb-4 text-xl font-bold text-black dark:text-neutral-200">
-          {prompt.name}
-        </div>
-
-        <div className="mb-4 text-sm italic text-black dark:text-neutral-200">
-          {prompt.description}
-        </div>
-
-        {updatedVariables.map((variable, index) => (
-          <div className="mb-4" key={index}>
-            <div className="mb-2 text-sm font-bold text-neutral-200">
-              {variable.key}
-            </div>
-
-            <textarea
-              ref={index === 0 ? nameInputRef : undefined}
-              className="mt-1 w-full rounded-lg border border-neutral-500 px-4 py-2 text-neutral-900 shadow focus:outline-none dark:border-neutral-800 dark:border-opacity-50 dark:bg-[#40414F] dark:text-neutral-100"
-              style={{ resize: 'none' }}
-              placeholder={`Enter a value for ${variable.key}...`}
-              value={variable.value}
-              onChange={(e) => handleChange(index, e.target.value)}
-              rows={3}
-            />
-          </div>
-        ))}
-
-        <button
-          className="mt-6 w-full rounded-lg border border-neutral-500 px-4 py-2 text-neutral-900 shadow hover:bg-neutral-100 focus:outline-none dark:border-neutral-800 dark:border-opacity-50 dark:bg-white dark:text-black dark:hover:bg-neutral-300"
-          onClick={handleSubmit}
-        >
-          Submit
-        </button>
-      </div>
-    </div>
-  );
-};
diff --git a/spaces/merle/PROTEIN_GENERATOR/examples/secondary_structure_from_pdb.sh b/spaces/merle/PROTEIN_GENERATOR/examples/secondary_structure_from_pdb.sh
deleted file mode 100644
index b548870e8eade138a4c59ebada89fb4ab2a9ec68..0000000000000000000000000000000000000000
--- a/spaces/merle/PROTEIN_GENERATOR/examples/secondary_structure_from_pdb.sh
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/bin/bash
-#SBATCH -J seq_diff
-#SBATCH -p gpu
-#SBATCH --mem=8g
-#SBATCH --gres=gpu:a6000:1
-#SBATCH -o ./out/slurm/slurm_%j.out
-
-source activate /software/conda/envs/SE3nv
-
-srun python ../inference.py \
-    --num_designs 10 \
-    --out out/design \
-    --contigs 110 \
-    --T 25 --save_best_plddt \
-    --dssp_pdb ./pdbs/cd86.pdb
-
-# FOR SECONDARY STRUCTURE:
-#   X - mask
-#   H - helix
-#   E - strand
-#   L - loop
diff --git a/spaces/merve/data-leak/public/anonymization/annotations.js b/spaces/merve/data-leak/public/anonymization/annotations.js
deleted file mode 100644
index ed45db46369d1bb2a709b20bd97c29451d4284c0..0000000000000000000000000000000000000000
--- a/spaces/merve/data-leak/public/anonymization/annotations.js
+++ /dev/null
@@ -1,38 +0,0 @@
-var annotations = 
-
-[
-]
-
-
-
-
-function addSwoop(c){
-  var swoopy = d3.swoopyDrag()
-    .x(d => c.x(d.x))
-    .y(d => c.y(d.y))
-    .draggable(0)
-    .annotations(annotations)
-
-  var swoopySel = c.svg.append('g.annotations').call(swoopy)
-
-  c.svg.append('marker#arrow')
-      .attr('viewBox', '-10 -10 20 20')
-      .attr('markerWidth', 20)
-      .attr('markerHeight', 20)
-      .attr('orient', 'auto')
-    .append('path').at({d: 'M-6.75,-6.75 L 0,0 L -6.75,6.75'})
-
-
-  swoopySel.selectAll('path').attr('marker-end', 'url(#arrow)')
-  window.annotationSel = swoopySel.selectAll('g')
-    .st({fontSize: 12, opacity: d => d.slide == 0 ? 1 : 0})
-
-  swoopySel.selectAll('text')
-    .each(function(d){
-      d3.select(this)
-        .text('')                        //clear existing text
-        .tspans(d3.wordwrap(d.text, d.width || 20), 12) //wrap after 20 char
-    })  
-}
-
-
diff --git a/spaces/merve/dataset-worldviews/public/measuring-fairness/slider.js b/spaces/merve/dataset-worldviews/public/measuring-fairness/slider.js
deleted file mode 100644
index efcbc18387d0d0cb957e34f75bb20a83131dda8e..0000000000000000000000000000000000000000
--- a/spaces/merve/dataset-worldviews/public/measuring-fairness/slider.js
+++ /dev/null
@@ -1,139 +0,0 @@
-/* Copyright 2020 Google LLC. 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.
-==============================================================================*/
-
-
-
-
-
-
-
-
-window.makeSlider = function(){
-
-  var width = 300
-  var height = 30
-
-  var x = d3.scaleLinear()
-    .domain([.99, .6])
-    .range([0, width])
-    .clamp(true)
-
-  var rv = {}
-  rv.threshold = .5
-  rv.setSlider = makeSetSlider(students, 'threshold')
-  rv.setSliderF = makeSetSlider(students.filter(d => !d.isMale), 'threshold_f')
-  rv.setSliderM = makeSetSlider(students.filter(d => d.isMale), 'threshold_m')
-
-  var allActiveSel = d3.selectAll('.threshold-rect')
-  var allHandleSel = d3.selectAll('.threshold-handle')
-
-  var gatedSel = d3.select('.gated')
-
-  function makeSetSlider(data, key){
-    var text = key.split('_')[1]
-
-
-    var drag = d3.drag()
-      .on('drag', function(d){
-        updateThreshold(x.invert(d3.mouse(this)[0]))
-        // console.log(d3.event.x)
-
-        if (text && slider.threshold_f && (slider.threshold_f > 0.9042 || slider.threshold_f - slider.threshold_m > .05)){
-          gatedSel.classed('opened', 1)
-          svg.classed('no-blink', 1)
-        }
-
-        if (key == 'threshold') svg.classed('no-blink', 1)
-      })
-
-    var svg = d3.select('.slider.' + key).html('')
-      .append('svg').at({width, height})
-      .call(drag)
-      .st({cursor: 'pointer'})
-
-    if (key == 'threshold_m') svg.classed('no-blink', 1)
-
-
-
-    svg.append('rect').at({width, height, fill: lcolors.well})
-
-    var rectSel = svg.append('rect.threshold-rect')
-      .at({width, height, fill: lcolors.sick})
-
-    var handleSel = svg.append('g.threshold-handle')
-    handleSel.append('text.cursor')
-      .text('▲')
-      .at({textAnchor: 'middle', fontSize: 10, y: height, dy: '.8em'})
-    handleSel.append('circle')
-      .at({cy: height, r: 30, fill: 'rgba(0,0,0,0)'})
-
-    var labelText = 'Model Aggressiveness _→'
-    var _replacement = !text ? '' : 'On ' + (text == 'f' ? 'Women ' : 'Men ')
-
-    var labelText = '_Model Aggressiveness →'
-    var _replacement = !text ? '' : (text == 'f' ? 'Adult ' : 'Adult ')
-
-    var labelText = '_Model Decision Point'
-    var _replacement = !text ? '' : (text == 'f' ? 'Adult ' : 'Adult ')
-
-    var labelText = 'Model Decision Point_'
-    var _replacement = !text ? '' : (text == 'f' ? ' for Adults ' : ' for Children ')
-
-    var labelText = '_ Model Aggressiveness →'
-    var _replacement = !text ? '' : (text == 'f' ? ' Adult ' : 'Child ')
-
-
-    svg.append('text.axis').text(labelText.replace('_', _replacement))
-      .at({y: height/2, dy: '.33em', dx: 10})
-      .st({pointerEvents: 'none'})
-
-
-
-    function updateThreshold(threshold, skipDom){
-      rv[key] = threshold
-      data.forEach(d => d.threshold = threshold)
-
-      mini.updateAll()
-
-      rectSel.at({width: x(threshold)})
-      handleSel.translate(x(threshold), 0)
-
-      if (skipDom) return
-
-      if (key == 'threshold'){
-        allActiveSel.at({width: x(threshold)})
-        allHandleSel.translate(x(threshold), 0)
-      }
-
-      sel.rectSel.at({fill: d => d.grade > d.threshold ? lcolors.sick : lcolors.well})
-      sel.textSel
-        .st({
-          strokeWidth: d => d.grade > d.threshold == d.isSick ? 0 : .6,
-        })
-
-    }
-
-    return updateThreshold
-  }
-
-  return rv
-}
-
-
-
-
-
-
-if (window.init) window.init()
diff --git a/spaces/merve/measuring-fairness/server-side/fill-in-the-blank/scatter-plot-colab/two-sentences/init-scatter.js b/spaces/merve/measuring-fairness/server-side/fill-in-the-blank/scatter-plot-colab/two-sentences/init-scatter.js
deleted file mode 100644
index 574d25c9334964f44bf9ab191c5099c84f1b1c47..0000000000000000000000000000000000000000
--- a/spaces/merve/measuring-fairness/server-side/fill-in-the-blank/scatter-plot-colab/two-sentences/init-scatter.js
+++ /dev/null
@@ -1,103 +0,0 @@
-/* Copyright 2021 Google LLC. 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.
-==============================================================================*/
-
-
-window.hoverCBs = []
-window.initScatter = function(){
-
-  function draw(c, data){
-
-    var [svgbot, ctx, svg] = c.layers
-    if (!ctx || !ctx.fillRect) return
-
-    data.forEach(d => {
-      if (!d.isVisible) return
-      d.prettyWord = d.word.replace('▁', '')
-      ctx.fillStyle = d.fill
-      ctx.fillRect(d.x - d.s/2, d.y - d.s/2, d.s, d.s)
-    })
-
-    var curHover = ''
-    var hoverSel = svg.append('g.hover').st({opacity: 0, pointerEvents: 'none'})
-      
-    hoverSel.append('circle')
-      .at({r: 5, fill: 'none', stroke: '#000'})
-    var hoverTextSel = hoverSel.appendMany('text', [0, 1])
-      .at({x: 10, y: 5, stroke: d => d ? '' : '#000'})
-      .st({fontFamily: 'monospace'})
-
-    svgbot.append('rect')
-      // .at({width: c.width, height: c.height, fill: '#fff'})
-    svg.append('rect')
-      .at({width: c.width, height: c.height, fill: 'rgba(0,0,0,0)'})
-
-    svg
-      .appendMany('text.tiny', data.filter(d => d.show))
-      .text(d => d.prettyWord)
-      .translate(d => [d.x, d.y])
-      .at({
-        dy: d => d.show[0] == 'u' ? -2 : 10, 
-        dx: d => d.show[1] == 'r' ? 2 : -2, 
-        textAnchor: d => d.show[1] == 'r' ? '' : 'end',
-        fill: d => d.fill,
-      })
-      .st({pointerEvents: 'none'})
-
-
-    svg
-      // .call(d3.attachTooltip)
-      .on('mousemove', function(){
-        var [x, y] = d3.mouse(this)
-
-        var match = _.minBy(data, d => {
-          var dx = x - d.x
-          var dy = y - d.y
-
-          return dx*dx + dy*dy
-        })
-
-        // if (curHover != match.word) return
-
-        hoverCBs.forEach(fn => fn(match.word))
-      })
-      .on('mouseout', function(){
-        hoverCBs.forEach(fn => fn(null))
-        curHover = ''
-      })
-
-    function setHover(word){
-      var d = _.find(data, {word})
-      if (!d || isNaN(d.dif)){
-        hoverSel.st({opacity: 0})
-        hoverTextSel.text('')
-        return 
-      }
-      curHover = word
-
-      hoverSel.translate([d.x, d.y]).raise().st({opacity: 1})
-      hoverTextSel.text(d.prettyWord)
-    }
-
-    hoverCBs.push(setHover)
-
-  }
-
-  return {draw}
-}
-
-
-if (window.init) init()
-
-
diff --git a/spaces/merve/measuring-fairness/source/base-rate/style.css b/spaces/merve/measuring-fairness/source/base-rate/style.css
deleted file mode 100644
index 5ba8d020fda588a3e7f61ff3fab4d377aa3bd4f2..0000000000000000000000000000000000000000
--- a/spaces/merve/measuring-fairness/source/base-rate/style.css
+++ /dev/null
@@ -1,134 +0,0 @@
-/* Copyright 2020 Google LLC. 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.
-==============================================================================*/
-
-
-
-.tooltip {
-  top: -1000px;
-  position: fixed;
-  padding: 10px;
-  background: rgba(255, 255, 255, .90);
-  border: 1px solid lightgray;
-  pointer-events: none;
-  width: auto;
-
-}
-.tooltip-hidden{
-  opacity: 0;
-  transition: all .3s;
-  transition-delay: .1s;
-}
-
-@media (max-width: 590px){
-  div.tooltip{
-    bottom: -1px;
-    width: calc(100%);
-    left: -1px !important;
-    right: -1px !important;
-    top: auto !important;
-    width: auto !important;
-  }
-}
-
-svg{
-  overflow: visible;
-}
-
-.domain{
-  display: none;
-}
-
-#big-matrix text{
-  font-family: 'Google Sans', sans-serif;
-  /*pointer-events: none;*/
-  text-shadow: 0 1px 0 #fff, 1px 0 0 #fff, 0 -1px 0 #fff, -1px 0 0 #fff;
-  text-shadow: 0 1px 0 rgba(255,255,255, .6), 1px 0 0 rgba(255,255,255, .6), 0 -1px 0 rgba(255,255,255, .6), -1px 0 0 rgba(255,255,255, .6);
-}
-
-
-body{
-  max-width: 900px;
-}
-
-h1{
-}
-
-h1{
-  /*text-align: center;*/
-}
-
-h3{
-  font-size: 20px;
-}
-#big-matrix{
-  text-align: center;
-  margin-top: 40px;
-  font-family: 'Google Sans', sans-serif;
-
-}
-div.big-container{
-  display: inline-block;
-  margin: 10px;
-}
-
-#metrics{
-  text-align: center;
-}
-div.metrics-container{
-  display: inline-block;
-  margin: 10px;
-}
-
-div.metrics-container > div{
-  display: inline-block;
-  vertical-align: middle;
-  pointer-events: none;
-}
-
-
-
-
-.drag{
-  cursor: pointer;
-  fill-opacity: 0;
-  fill: #f0f;
-  stroke-opacity: 0;
-}
-
-svg.dragging{
-  cursor: pointer;
-}
-
-sl{
-  /*background: #000; */
-  color: #000;
-  border: 1px solid #eee;
-  width: 1em; 
-  display: inline-block;
-  padding-left: 2px;
-  padding-right: 2px;
-  font-style: normal;
-}
-
-#instructions{
-  margin-top: 10px;
-  margin-bottom: 10px;
-  text-align: center;
-}
-
-
-
-
-
diff --git a/spaces/mikebars/huggingface/assets/index-d33dc745.js b/spaces/mikebars/huggingface/assets/index-d33dc745.js
deleted file mode 100644
index d5aa666fe6342a7c642835e1c922d4f65b6e9e07..0000000000000000000000000000000000000000
--- a/spaces/mikebars/huggingface/assets/index-d33dc745.js
+++ /dev/null
@@ -1,41 +0,0 @@
-var Dc=Object.defineProperty;var $c=(e,t,n)=>t in e?Dc(e,t,{enumerable:!0,configurable:!0,writable:!0,value:n}):e[t]=n;var hn=(e,t,n)=>($c(e,typeof t!="symbol"?t+"":t,n),n);(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const l of document.querySelectorAll('link[rel="modulepreload"]'))r(l);new MutationObserver(l=>{for(const i of l)if(i.type==="childList")for(const o of i.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&r(o)}).observe(document,{childList:!0,subtree:!0});function n(l){const i={};return l.integrity&&(i.integrity=l.integrity),l.referrerPolicy&&(i.referrerPolicy=l.referrerPolicy),l.crossOrigin==="use-credentials"?i.credentials="include":l.crossOrigin==="anonymous"?i.credentials="omit":i.credentials="same-origin",i}function r(l){if(l.ep)return;l.ep=!0;const i=n(l);fetch(l.href,i)}})();var bu={exports:{}},ul={},es={exports:{}},I={};/**
- * @license React
- * react.production.min.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */var tr=Symbol.for("react.element"),Uc=Symbol.for("react.portal"),Vc=Symbol.for("react.fragment"),Bc=Symbol.for("react.strict_mode"),Qc=Symbol.for("react.profiler"),Hc=Symbol.for("react.provider"),Wc=Symbol.for("react.context"),Kc=Symbol.for("react.forward_ref"),Yc=Symbol.for("react.suspense"),Xc=Symbol.for("react.memo"),Gc=Symbol.for("react.lazy"),Qo=Symbol.iterator;function Zc(e){return e===null||typeof e!="object"?null:(e=Qo&&e[Qo]||e["@@iterator"],typeof e=="function"?e:null)}var ts={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},ns=Object.assign,rs={};function cn(e,t,n){this.props=e,this.context=t,this.refs=rs,this.updater=n||ts}cn.prototype.isReactComponent={};cn.prototype.setState=function(e,t){if(typeof e!="object"&&typeof e!="function"&&e!=null)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,e,t,"setState")};cn.prototype.forceUpdate=function(e){this.updater.enqueueForceUpdate(this,e,"forceUpdate")};function ls(){}ls.prototype=cn.prototype;function Wi(e,t,n){this.props=e,this.context=t,this.refs=rs,this.updater=n||ts}var Ki=Wi.prototype=new ls;Ki.constructor=Wi;ns(Ki,cn.prototype);Ki.isPureReactComponent=!0;var Ho=Array.isArray,is=Object.prototype.hasOwnProperty,Yi={current:null},os={key:!0,ref:!0,__self:!0,__source:!0};function us(e,t,n){var r,l={},i=null,o=null;if(t!=null)for(r in t.ref!==void 0&&(o=t.ref),t.key!==void 0&&(i=""+t.key),t)is.call(t,r)&&!os.hasOwnProperty(r)&&(l[r]=t[r]);var u=arguments.length-2;if(u===1)l.children=n;else if(1<u){for(var s=Array(u),c=0;c<u;c++)s[c]=arguments[c+2];l.children=s}if(e&&e.defaultProps)for(r in u=e.defaultProps,u)l[r]===void 0&&(l[r]=u[r]);return{$$typeof:tr,type:e,key:i,ref:o,props:l,_owner:Yi.current}}function qc(e,t){return{$$typeof:tr,type:e.type,key:t,ref:e.ref,props:e.props,_owner:e._owner}}function Xi(e){return typeof e=="object"&&e!==null&&e.$$typeof===tr}function Jc(e){var t={"=":"=0",":":"=2"};return"$"+e.replace(/[=:]/g,function(n){return t[n]})}var Wo=/\/+/g;function _l(e,t){return typeof e=="object"&&e!==null&&e.key!=null?Jc(""+e.key):t.toString(36)}function jr(e,t,n,r,l){var i=typeof e;(i==="undefined"||i==="boolean")&&(e=null);var o=!1;if(e===null)o=!0;else switch(i){case"string":case"number":o=!0;break;case"object":switch(e.$$typeof){case tr:case Uc:o=!0}}if(o)return o=e,l=l(o),e=r===""?"."+_l(o,0):r,Ho(l)?(n="",e!=null&&(n=e.replace(Wo,"$&/")+"/"),jr(l,t,n,"",function(c){return c})):l!=null&&(Xi(l)&&(l=qc(l,n+(!l.key||o&&o.key===l.key?"":(""+l.key).replace(Wo,"$&/")+"/")+e)),t.push(l)),1;if(o=0,r=r===""?".":r+":",Ho(e))for(var u=0;u<e.length;u++){i=e[u];var s=r+_l(i,u);o+=jr(i,t,n,s,l)}else if(s=Zc(e),typeof s=="function")for(e=s.call(e),u=0;!(i=e.next()).done;)i=i.value,s=r+_l(i,u++),o+=jr(i,t,n,s,l);else if(i==="object")throw t=String(e),Error("Objects are not valid as a React child (found: "+(t==="[object Object]"?"object with keys {"+Object.keys(e).join(", ")+"}":t)+"). If you meant to render a collection of children, use an array instead.");return o}function sr(e,t,n){if(e==null)return e;var r=[],l=0;return jr(e,r,"","",function(i){return t.call(n,i,l++)}),r}function bc(e){if(e._status===-1){var t=e._result;t=t(),t.then(function(n){(e._status===0||e._status===-1)&&(e._status=1,e._result=n)},function(n){(e._status===0||e._status===-1)&&(e._status=2,e._result=n)}),e._status===-1&&(e._status=0,e._result=t)}if(e._status===1)return e._result.default;throw e._result}var pe={current:null},_r={transition:null},ef={ReactCurrentDispatcher:pe,ReactCurrentBatchConfig:_r,ReactCurrentOwner:Yi};I.Children={map:sr,forEach:function(e,t,n){sr(e,function(){t.apply(this,arguments)},n)},count:function(e){var t=0;return sr(e,function(){t++}),t},toArray:function(e){return sr(e,function(t){return t})||[]},only:function(e){if(!Xi(e))throw Error("React.Children.only expected to receive a single React element child.");return e}};I.Component=cn;I.Fragment=Vc;I.Profiler=Qc;I.PureComponent=Wi;I.StrictMode=Bc;I.Suspense=Yc;I.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ef;I.cloneElement=function(e,t,n){if(e==null)throw Error("React.cloneElement(...): The argument must be a React element, but you passed "+e+".");var r=ns({},e.props),l=e.key,i=e.ref,o=e._owner;if(t!=null){if(t.ref!==void 0&&(i=t.ref,o=Yi.current),t.key!==void 0&&(l=""+t.key),e.type&&e.type.defaultProps)var u=e.type.defaultProps;for(s in t)is.call(t,s)&&!os.hasOwnProperty(s)&&(r[s]=t[s]===void 0&&u!==void 0?u[s]:t[s])}var s=arguments.length-2;if(s===1)r.children=n;else if(1<s){u=Array(s);for(var c=0;c<s;c++)u[c]=arguments[c+2];r.children=u}return{$$typeof:tr,type:e.type,key:l,ref:i,props:r,_owner:o}};I.createContext=function(e){return e={$$typeof:Wc,_currentValue:e,_currentValue2:e,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null},e.Provider={$$typeof:Hc,_context:e},e.Consumer=e};I.createElement=us;I.createFactory=function(e){var t=us.bind(null,e);return t.type=e,t};I.createRef=function(){return{current:null}};I.forwardRef=function(e){return{$$typeof:Kc,render:e}};I.isValidElement=Xi;I.lazy=function(e){return{$$typeof:Gc,_payload:{_status:-1,_result:e},_init:bc}};I.memo=function(e,t){return{$$typeof:Xc,type:e,compare:t===void 0?null:t}};I.startTransition=function(e){var t=_r.transition;_r.transition={};try{e()}finally{_r.transition=t}};I.unstable_act=function(){throw Error("act(...) is not supported in production builds of React.")};I.useCallback=function(e,t){return pe.current.useCallback(e,t)};I.useContext=function(e){return pe.current.useContext(e)};I.useDebugValue=function(){};I.useDeferredValue=function(e){return pe.current.useDeferredValue(e)};I.useEffect=function(e,t){return pe.current.useEffect(e,t)};I.useId=function(){return pe.current.useId()};I.useImperativeHandle=function(e,t,n){return pe.current.useImperativeHandle(e,t,n)};I.useInsertionEffect=function(e,t){return pe.current.useInsertionEffect(e,t)};I.useLayoutEffect=function(e,t){return pe.current.useLayoutEffect(e,t)};I.useMemo=function(e,t){return pe.current.useMemo(e,t)};I.useReducer=function(e,t,n){return pe.current.useReducer(e,t,n)};I.useRef=function(e){return pe.current.useRef(e)};I.useState=function(e){return pe.current.useState(e)};I.useSyncExternalStore=function(e,t,n){return pe.current.useSyncExternalStore(e,t,n)};I.useTransition=function(){return pe.current.useTransition()};I.version="18.2.0";es.exports=I;var m=es.exports;/**
- * @license React
- * react-jsx-runtime.production.min.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */var tf=m,nf=Symbol.for("react.element"),rf=Symbol.for("react.fragment"),lf=Object.prototype.hasOwnProperty,of=tf.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,uf={key:!0,ref:!0,__self:!0,__source:!0};function ss(e,t,n){var r,l={},i=null,o=null;n!==void 0&&(i=""+n),t.key!==void 0&&(i=""+t.key),t.ref!==void 0&&(o=t.ref);for(r in t)lf.call(t,r)&&!uf.hasOwnProperty(r)&&(l[r]=t[r]);if(e&&e.defaultProps)for(r in t=e.defaultProps,t)l[r]===void 0&&(l[r]=t[r]);return{$$typeof:nf,type:e,key:i,ref:o,props:l,_owner:of.current}}ul.Fragment=rf;ul.jsx=ss;ul.jsxs=ss;bu.exports=ul;var a=bu.exports,as={exports:{}},Ce={},cs={exports:{}},fs={};/**
- * @license React
- * scheduler.production.min.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */(function(e){function t(j,P){var L=j.length;j.push(P);e:for(;0<L;){var X=L-1>>>1,te=j[X];if(0<l(te,P))j[X]=P,j[L]=te,L=X;else break e}}function n(j){return j.length===0?null:j[0]}function r(j){if(j.length===0)return null;var P=j[0],L=j.pop();if(L!==P){j[0]=L;e:for(var X=0,te=j.length,or=te>>>1;X<or;){var xt=2*(X+1)-1,jl=j[xt],kt=xt+1,ur=j[kt];if(0>l(jl,L))kt<te&&0>l(ur,jl)?(j[X]=ur,j[kt]=L,X=kt):(j[X]=jl,j[xt]=L,X=xt);else if(kt<te&&0>l(ur,L))j[X]=ur,j[kt]=L,X=kt;else break e}}return P}function l(j,P){var L=j.sortIndex-P.sortIndex;return L!==0?L:j.id-P.id}if(typeof performance=="object"&&typeof performance.now=="function"){var i=performance;e.unstable_now=function(){return i.now()}}else{var o=Date,u=o.now();e.unstable_now=function(){return o.now()-u}}var s=[],c=[],y=1,f=null,v=3,g=!1,w=!1,k=!1,M=typeof setTimeout=="function"?setTimeout:null,p=typeof clearTimeout=="function"?clearTimeout:null,d=typeof setImmediate<"u"?setImmediate:null;typeof navigator<"u"&&navigator.scheduling!==void 0&&navigator.scheduling.isInputPending!==void 0&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function h(j){for(var P=n(c);P!==null;){if(P.callback===null)r(c);else if(P.startTime<=j)r(c),P.sortIndex=P.expirationTime,t(s,P);else break;P=n(c)}}function S(j){if(k=!1,h(j),!w)if(n(s)!==null)w=!0,El(C);else{var P=n(c);P!==null&&Cl(S,P.startTime-j)}}function C(j,P){w=!1,k&&(k=!1,p(O),O=-1),g=!0;var L=v;try{for(h(P),f=n(s);f!==null&&(!(f.expirationTime>P)||j&&!Le());){var X=f.callback;if(typeof X=="function"){f.callback=null,v=f.priorityLevel;var te=X(f.expirationTime<=P);P=e.unstable_now(),typeof te=="function"?f.callback=te:f===n(s)&&r(s),h(P)}else r(s);f=n(s)}if(f!==null)var or=!0;else{var xt=n(c);xt!==null&&Cl(S,xt.startTime-P),or=!1}return or}finally{f=null,v=L,g=!1}}var _=!1,N=null,O=-1,Y=5,F=-1;function Le(){return!(e.unstable_now()-F<Y)}function mn(){if(N!==null){var j=e.unstable_now();F=j;var P=!0;try{P=N(!0,j)}finally{P?yn():(_=!1,N=null)}}else _=!1}var yn;if(typeof d=="function")yn=function(){d(mn)};else if(typeof MessageChannel<"u"){var Bo=new MessageChannel,Mc=Bo.port2;Bo.port1.onmessage=mn,yn=function(){Mc.postMessage(null)}}else yn=function(){M(mn,0)};function El(j){N=j,_||(_=!0,yn())}function Cl(j,P){O=M(function(){j(e.unstable_now())},P)}e.unstable_IdlePriority=5,e.unstable_ImmediatePriority=1,e.unstable_LowPriority=4,e.unstable_NormalPriority=3,e.unstable_Profiling=null,e.unstable_UserBlockingPriority=2,e.unstable_cancelCallback=function(j){j.callback=null},e.unstable_continueExecution=function(){w||g||(w=!0,El(C))},e.unstable_forceFrameRate=function(j){0>j||125<j?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):Y=0<j?Math.floor(1e3/j):5},e.unstable_getCurrentPriorityLevel=function(){return v},e.unstable_getFirstCallbackNode=function(){return n(s)},e.unstable_next=function(j){switch(v){case 1:case 2:case 3:var P=3;break;default:P=v}var L=v;v=P;try{return j()}finally{v=L}},e.unstable_pauseExecution=function(){},e.unstable_requestPaint=function(){},e.unstable_runWithPriority=function(j,P){switch(j){case 1:case 2:case 3:case 4:case 5:break;default:j=3}var L=v;v=j;try{return P()}finally{v=L}},e.unstable_scheduleCallback=function(j,P,L){var X=e.unstable_now();switch(typeof L=="object"&&L!==null?(L=L.delay,L=typeof L=="number"&&0<L?X+L:X):L=X,j){case 1:var te=-1;break;case 2:te=250;break;case 5:te=1073741823;break;case 4:te=1e4;break;default:te=5e3}return te=L+te,j={id:y++,callback:P,priorityLevel:j,startTime:L,expirationTime:te,sortIndex:-1},L>X?(j.sortIndex=L,t(c,j),n(s)===null&&j===n(c)&&(k?(p(O),O=-1):k=!0,Cl(S,L-X))):(j.sortIndex=te,t(s,j),w||g||(w=!0,El(C))),j},e.unstable_shouldYield=Le,e.unstable_wrapCallback=function(j){var P=v;return function(){var L=v;v=P;try{return j.apply(this,arguments)}finally{v=L}}}})(fs);cs.exports=fs;var sf=cs.exports;/**
- * @license React
- * react-dom.production.min.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */var ds=m,Ee=sf;function x(e){for(var t="https://reactjs.org/docs/error-decoder.html?invariant="+e,n=1;n<arguments.length;n++)t+="&args[]="+encodeURIComponent(arguments[n]);return"Minified React error #"+e+"; visit "+t+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}var ps=new Set,Dn={};function Rt(e,t){nn(e,t),nn(e+"Capture",t)}function nn(e,t){for(Dn[e]=t,e=0;e<t.length;e++)ps.add(t[e])}var Ze=!(typeof window>"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),bl=Object.prototype.hasOwnProperty,af=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,Ko={},Yo={};function cf(e){return bl.call(Yo,e)?!0:bl.call(Ko,e)?!1:af.test(e)?Yo[e]=!0:(Ko[e]=!0,!1)}function ff(e,t,n,r){if(n!==null&&n.type===0)return!1;switch(typeof t){case"function":case"symbol":return!0;case"boolean":return r?!1:n!==null?!n.acceptsBooleans:(e=e.toLowerCase().slice(0,5),e!=="data-"&&e!=="aria-");default:return!1}}function df(e,t,n,r){if(t===null||typeof t>"u"||ff(e,t,n,r))return!0;if(r)return!1;if(n!==null)switch(n.type){case 3:return!t;case 4:return t===!1;case 5:return isNaN(t);case 6:return isNaN(t)||1>t}return!1}function me(e,t,n,r,l,i,o){this.acceptsBooleans=t===2||t===3||t===4,this.attributeName=r,this.attributeNamespace=l,this.mustUseProperty=n,this.propertyName=e,this.type=t,this.sanitizeURL=i,this.removeEmptyString=o}var oe={};"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(e){oe[e]=new me(e,0,!1,e,null,!1,!1)});[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(e){var t=e[0];oe[t]=new me(t,1,!1,e[1],null,!1,!1)});["contentEditable","draggable","spellCheck","value"].forEach(function(e){oe[e]=new me(e,2,!1,e.toLowerCase(),null,!1,!1)});["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(e){oe[e]=new me(e,2,!1,e,null,!1,!1)});"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(e){oe[e]=new me(e,3,!1,e.toLowerCase(),null,!1,!1)});["checked","multiple","muted","selected"].forEach(function(e){oe[e]=new me(e,3,!0,e,null,!1,!1)});["capture","download"].forEach(function(e){oe[e]=new me(e,4,!1,e,null,!1,!1)});["cols","rows","size","span"].forEach(function(e){oe[e]=new me(e,6,!1,e,null,!1,!1)});["rowSpan","start"].forEach(function(e){oe[e]=new me(e,5,!1,e.toLowerCase(),null,!1,!1)});var Gi=/[\-:]([a-z])/g;function Zi(e){return e[1].toUpperCase()}"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(e){var t=e.replace(Gi,Zi);oe[t]=new me(t,1,!1,e,null,!1,!1)});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(e){var t=e.replace(Gi,Zi);oe[t]=new me(t,1,!1,e,"http://www.w3.org/1999/xlink",!1,!1)});["xml:base","xml:lang","xml:space"].forEach(function(e){var t=e.replace(Gi,Zi);oe[t]=new me(t,1,!1,e,"http://www.w3.org/XML/1998/namespace",!1,!1)});["tabIndex","crossOrigin"].forEach(function(e){oe[e]=new me(e,1,!1,e.toLowerCase(),null,!1,!1)});oe.xlinkHref=new me("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(e){oe[e]=new me(e,1,!1,e.toLowerCase(),null,!0,!0)});function qi(e,t,n,r){var l=oe.hasOwnProperty(t)?oe[t]:null;(l!==null?l.type!==0:r||!(2<t.length)||t[0]!=="o"&&t[0]!=="O"||t[1]!=="n"&&t[1]!=="N")&&(df(t,n,l,r)&&(n=null),r||l===null?cf(t)&&(n===null?e.removeAttribute(t):e.setAttribute(t,""+n)):l.mustUseProperty?e[l.propertyName]=n===null?l.type===3?!1:"":n:(t=l.attributeName,r=l.attributeNamespace,n===null?e.removeAttribute(t):(l=l.type,n=l===3||l===4&&n===!0?"":""+n,r?e.setAttributeNS(r,t,n):e.setAttribute(t,n))))}var et=ds.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,ar=Symbol.for("react.element"),Dt=Symbol.for("react.portal"),$t=Symbol.for("react.fragment"),Ji=Symbol.for("react.strict_mode"),ei=Symbol.for("react.profiler"),ms=Symbol.for("react.provider"),ys=Symbol.for("react.context"),bi=Symbol.for("react.forward_ref"),ti=Symbol.for("react.suspense"),ni=Symbol.for("react.suspense_list"),eo=Symbol.for("react.memo"),nt=Symbol.for("react.lazy"),hs=Symbol.for("react.offscreen"),Xo=Symbol.iterator;function vn(e){return e===null||typeof e!="object"?null:(e=Xo&&e[Xo]||e["@@iterator"],typeof e=="function"?e:null)}var H=Object.assign,Nl;function jn(e){if(Nl===void 0)try{throw Error()}catch(n){var t=n.stack.trim().match(/\n( *(at )?)/);Nl=t&&t[1]||""}return`
-`+Nl+e}var Ol=!1;function Tl(e,t){if(!e||Ol)return"";Ol=!0;var n=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(t)if(t=function(){throw Error()},Object.defineProperty(t.prototype,"props",{set:function(){throw Error()}}),typeof Reflect=="object"&&Reflect.construct){try{Reflect.construct(t,[])}catch(c){var r=c}Reflect.construct(e,[],t)}else{try{t.call()}catch(c){r=c}e.call(t.prototype)}else{try{throw Error()}catch(c){r=c}e()}}catch(c){if(c&&r&&typeof c.stack=="string"){for(var l=c.stack.split(`
-`),i=r.stack.split(`
-`),o=l.length-1,u=i.length-1;1<=o&&0<=u&&l[o]!==i[u];)u--;for(;1<=o&&0<=u;o--,u--)if(l[o]!==i[u]){if(o!==1||u!==1)do if(o--,u--,0>u||l[o]!==i[u]){var s=`
-`+l[o].replace(" at new "," at ");return e.displayName&&s.includes("<anonymous>")&&(s=s.replace("<anonymous>",e.displayName)),s}while(1<=o&&0<=u);break}}}finally{Ol=!1,Error.prepareStackTrace=n}return(e=e?e.displayName||e.name:"")?jn(e):""}function pf(e){switch(e.tag){case 5:return jn(e.type);case 16:return jn("Lazy");case 13:return jn("Suspense");case 19:return jn("SuspenseList");case 0:case 2:case 15:return e=Tl(e.type,!1),e;case 11:return e=Tl(e.type.render,!1),e;case 1:return e=Tl(e.type,!0),e;default:return""}}function ri(e){if(e==null)return null;if(typeof e=="function")return e.displayName||e.name||null;if(typeof e=="string")return e;switch(e){case $t:return"Fragment";case Dt:return"Portal";case ei:return"Profiler";case Ji:return"StrictMode";case ti:return"Suspense";case ni:return"SuspenseList"}if(typeof e=="object")switch(e.$$typeof){case ys:return(e.displayName||"Context")+".Consumer";case ms:return(e._context.displayName||"Context")+".Provider";case bi:var t=e.render;return e=e.displayName,e||(e=t.displayName||t.name||"",e=e!==""?"ForwardRef("+e+")":"ForwardRef"),e;case eo:return t=e.displayName||null,t!==null?t:ri(e.type)||"Memo";case nt:t=e._payload,e=e._init;try{return ri(e(t))}catch{}}return null}function mf(e){var t=e.type;switch(e.tag){case 24:return"Cache";case 9:return(t.displayName||"Context")+".Consumer";case 10:return(t._context.displayName||"Context")+".Provider";case 18:return"DehydratedFragment";case 11:return e=t.render,e=e.displayName||e.name||"",t.displayName||(e!==""?"ForwardRef("+e+")":"ForwardRef");case 7:return"Fragment";case 5:return t;case 4:return"Portal";case 3:return"Root";case 6:return"Text";case 16:return ri(t);case 8:return t===Ji?"StrictMode":"Mode";case 22:return"Offscreen";case 12:return"Profiler";case 21:return"Scope";case 13:return"Suspense";case 19:return"SuspenseList";case 25:return"TracingMarker";case 1:case 0:case 17:case 2:case 14:case 15:if(typeof t=="function")return t.displayName||t.name||null;if(typeof t=="string")return t}return null}function ht(e){switch(typeof e){case"boolean":case"number":case"string":case"undefined":return e;case"object":return e;default:return""}}function vs(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()==="input"&&(t==="checkbox"||t==="radio")}function yf(e){var t=vs(e)?"checked":"value",n=Object.getOwnPropertyDescriptor(e.constructor.prototype,t),r=""+e[t];if(!e.hasOwnProperty(t)&&typeof n<"u"&&typeof n.get=="function"&&typeof n.set=="function"){var l=n.get,i=n.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return l.call(this)},set:function(o){r=""+o,i.call(this,o)}}),Object.defineProperty(e,t,{enumerable:n.enumerable}),{getValue:function(){return r},setValue:function(o){r=""+o},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function cr(e){e._valueTracker||(e._valueTracker=yf(e))}function gs(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var n=t.getValue(),r="";return e&&(r=vs(e)?e.checked?"true":"false":e.value),e=r,e!==n?(t.setValue(e),!0):!1}function Mr(e){if(e=e||(typeof document<"u"?document:void 0),typeof e>"u")return null;try{return e.activeElement||e.body}catch{return e.body}}function li(e,t){var n=t.checked;return H({},t,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:n??e._wrapperState.initialChecked})}function Go(e,t){var n=t.defaultValue==null?"":t.defaultValue,r=t.checked!=null?t.checked:t.defaultChecked;n=ht(t.value!=null?t.value:n),e._wrapperState={initialChecked:r,initialValue:n,controlled:t.type==="checkbox"||t.type==="radio"?t.checked!=null:t.value!=null}}function ws(e,t){t=t.checked,t!=null&&qi(e,"checked",t,!1)}function ii(e,t){ws(e,t);var n=ht(t.value),r=t.type;if(n!=null)r==="number"?(n===0&&e.value===""||e.value!=n)&&(e.value=""+n):e.value!==""+n&&(e.value=""+n);else if(r==="submit"||r==="reset"){e.removeAttribute("value");return}t.hasOwnProperty("value")?oi(e,t.type,n):t.hasOwnProperty("defaultValue")&&oi(e,t.type,ht(t.defaultValue)),t.checked==null&&t.defaultChecked!=null&&(e.defaultChecked=!!t.defaultChecked)}function Zo(e,t,n){if(t.hasOwnProperty("value")||t.hasOwnProperty("defaultValue")){var r=t.type;if(!(r!=="submit"&&r!=="reset"||t.value!==void 0&&t.value!==null))return;t=""+e._wrapperState.initialValue,n||t===e.value||(e.value=t),e.defaultValue=t}n=e.name,n!==""&&(e.name=""),e.defaultChecked=!!e._wrapperState.initialChecked,n!==""&&(e.name=n)}function oi(e,t,n){(t!=="number"||Mr(e.ownerDocument)!==e)&&(n==null?e.defaultValue=""+e._wrapperState.initialValue:e.defaultValue!==""+n&&(e.defaultValue=""+n))}var _n=Array.isArray;function Zt(e,t,n,r){if(e=e.options,t){t={};for(var l=0;l<n.length;l++)t["$"+n[l]]=!0;for(n=0;n<e.length;n++)l=t.hasOwnProperty("$"+e[n].value),e[n].selected!==l&&(e[n].selected=l),l&&r&&(e[n].defaultSelected=!0)}else{for(n=""+ht(n),t=null,l=0;l<e.length;l++){if(e[l].value===n){e[l].selected=!0,r&&(e[l].defaultSelected=!0);return}t!==null||e[l].disabled||(t=e[l])}t!==null&&(t.selected=!0)}}function ui(e,t){if(t.dangerouslySetInnerHTML!=null)throw Error(x(91));return H({},t,{value:void 0,defaultValue:void 0,children:""+e._wrapperState.initialValue})}function qo(e,t){var n=t.value;if(n==null){if(n=t.children,t=t.defaultValue,n!=null){if(t!=null)throw Error(x(92));if(_n(n)){if(1<n.length)throw Error(x(93));n=n[0]}t=n}t==null&&(t=""),n=t}e._wrapperState={initialValue:ht(n)}}function Ss(e,t){var n=ht(t.value),r=ht(t.defaultValue);n!=null&&(n=""+n,n!==e.value&&(e.value=n),t.defaultValue==null&&e.defaultValue!==n&&(e.defaultValue=n)),r!=null&&(e.defaultValue=""+r)}function Jo(e){var t=e.textContent;t===e._wrapperState.initialValue&&t!==""&&t!==null&&(e.value=t)}function xs(e){switch(e){case"svg":return"http://www.w3.org/2000/svg";case"math":return"http://www.w3.org/1998/Math/MathML";default:return"http://www.w3.org/1999/xhtml"}}function si(e,t){return e==null||e==="http://www.w3.org/1999/xhtml"?xs(t):e==="http://www.w3.org/2000/svg"&&t==="foreignObject"?"http://www.w3.org/1999/xhtml":e}var fr,ks=function(e){return typeof MSApp<"u"&&MSApp.execUnsafeLocalFunction?function(t,n,r,l){MSApp.execUnsafeLocalFunction(function(){return e(t,n,r,l)})}:e}(function(e,t){if(e.namespaceURI!=="http://www.w3.org/2000/svg"||"innerHTML"in e)e.innerHTML=t;else{for(fr=fr||document.createElement("div"),fr.innerHTML="<svg>"+t.valueOf().toString()+"</svg>",t=fr.firstChild;e.firstChild;)e.removeChild(e.firstChild);for(;t.firstChild;)e.appendChild(t.firstChild)}});function $n(e,t){if(t){var n=e.firstChild;if(n&&n===e.lastChild&&n.nodeType===3){n.nodeValue=t;return}}e.textContent=t}var Tn={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},hf=["Webkit","ms","Moz","O"];Object.keys(Tn).forEach(function(e){hf.forEach(function(t){t=t+e.charAt(0).toUpperCase()+e.substring(1),Tn[t]=Tn[e]})});function Es(e,t,n){return t==null||typeof t=="boolean"||t===""?"":n||typeof t!="number"||t===0||Tn.hasOwnProperty(e)&&Tn[e]?(""+t).trim():t+"px"}function Cs(e,t){e=e.style;for(var n in t)if(t.hasOwnProperty(n)){var r=n.indexOf("--")===0,l=Es(n,t[n],r);n==="float"&&(n="cssFloat"),r?e.setProperty(n,l):e[n]=l}}var vf=H({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});function ai(e,t){if(t){if(vf[e]&&(t.children!=null||t.dangerouslySetInnerHTML!=null))throw Error(x(137,e));if(t.dangerouslySetInnerHTML!=null){if(t.children!=null)throw Error(x(60));if(typeof t.dangerouslySetInnerHTML!="object"||!("__html"in t.dangerouslySetInnerHTML))throw Error(x(61))}if(t.style!=null&&typeof t.style!="object")throw Error(x(62))}}function ci(e,t){if(e.indexOf("-")===-1)return typeof t.is=="string";switch(e){case"annotation-xml":case"color-profile":case"font-face":case"font-face-src":case"font-face-uri":case"font-face-format":case"font-face-name":case"missing-glyph":return!1;default:return!0}}var fi=null;function to(e){return e=e.target||e.srcElement||window,e.correspondingUseElement&&(e=e.correspondingUseElement),e.nodeType===3?e.parentNode:e}var di=null,qt=null,Jt=null;function bo(e){if(e=lr(e)){if(typeof di!="function")throw Error(x(280));var t=e.stateNode;t&&(t=dl(t),di(e.stateNode,e.type,t))}}function js(e){qt?Jt?Jt.push(e):Jt=[e]:qt=e}function _s(){if(qt){var e=qt,t=Jt;if(Jt=qt=null,bo(e),t)for(e=0;e<t.length;e++)bo(t[e])}}function Ns(e,t){return e(t)}function Os(){}var Pl=!1;function Ts(e,t,n){if(Pl)return e(t,n);Pl=!0;try{return Ns(e,t,n)}finally{Pl=!1,(qt!==null||Jt!==null)&&(Os(),_s())}}function Un(e,t){var n=e.stateNode;if(n===null)return null;var r=dl(n);if(r===null)return null;n=r[t];e:switch(t){case"onClick":case"onClickCapture":case"onDoubleClick":case"onDoubleClickCapture":case"onMouseDown":case"onMouseDownCapture":case"onMouseMove":case"onMouseMoveCapture":case"onMouseUp":case"onMouseUpCapture":case"onMouseEnter":(r=!r.disabled)||(e=e.type,r=!(e==="button"||e==="input"||e==="select"||e==="textarea")),e=!r;break e;default:e=!1}if(e)return null;if(n&&typeof n!="function")throw Error(x(231,t,typeof n));return n}var pi=!1;if(Ze)try{var gn={};Object.defineProperty(gn,"passive",{get:function(){pi=!0}}),window.addEventListener("test",gn,gn),window.removeEventListener("test",gn,gn)}catch{pi=!1}function gf(e,t,n,r,l,i,o,u,s){var c=Array.prototype.slice.call(arguments,3);try{t.apply(n,c)}catch(y){this.onError(y)}}var Pn=!1,Dr=null,$r=!1,mi=null,wf={onError:function(e){Pn=!0,Dr=e}};function Sf(e,t,n,r,l,i,o,u,s){Pn=!1,Dr=null,gf.apply(wf,arguments)}function xf(e,t,n,r,l,i,o,u,s){if(Sf.apply(this,arguments),Pn){if(Pn){var c=Dr;Pn=!1,Dr=null}else throw Error(x(198));$r||($r=!0,mi=c)}}function At(e){var t=e,n=e;if(e.alternate)for(;t.return;)t=t.return;else{e=t;do t=e,t.flags&4098&&(n=t.return),e=t.return;while(e)}return t.tag===3?n:null}function Ps(e){if(e.tag===13){var t=e.memoizedState;if(t===null&&(e=e.alternate,e!==null&&(t=e.memoizedState)),t!==null)return t.dehydrated}return null}function eu(e){if(At(e)!==e)throw Error(x(188))}function kf(e){var t=e.alternate;if(!t){if(t=At(e),t===null)throw Error(x(188));return t!==e?null:e}for(var n=e,r=t;;){var l=n.return;if(l===null)break;var i=l.alternate;if(i===null){if(r=l.return,r!==null){n=r;continue}break}if(l.child===i.child){for(i=l.child;i;){if(i===n)return eu(l),e;if(i===r)return eu(l),t;i=i.sibling}throw Error(x(188))}if(n.return!==r.return)n=l,r=i;else{for(var o=!1,u=l.child;u;){if(u===n){o=!0,n=l,r=i;break}if(u===r){o=!0,r=l,n=i;break}u=u.sibling}if(!o){for(u=i.child;u;){if(u===n){o=!0,n=i,r=l;break}if(u===r){o=!0,r=i,n=l;break}u=u.sibling}if(!o)throw Error(x(189))}}if(n.alternate!==r)throw Error(x(190))}if(n.tag!==3)throw Error(x(188));return n.stateNode.current===n?e:t}function zs(e){return e=kf(e),e!==null?Ls(e):null}function Ls(e){if(e.tag===5||e.tag===6)return e;for(e=e.child;e!==null;){var t=Ls(e);if(t!==null)return t;e=e.sibling}return null}var Is=Ee.unstable_scheduleCallback,tu=Ee.unstable_cancelCallback,Ef=Ee.unstable_shouldYield,Cf=Ee.unstable_requestPaint,G=Ee.unstable_now,jf=Ee.unstable_getCurrentPriorityLevel,no=Ee.unstable_ImmediatePriority,Fs=Ee.unstable_UserBlockingPriority,Ur=Ee.unstable_NormalPriority,_f=Ee.unstable_LowPriority,Rs=Ee.unstable_IdlePriority,sl=null,Qe=null;function Nf(e){if(Qe&&typeof Qe.onCommitFiberRoot=="function")try{Qe.onCommitFiberRoot(sl,e,void 0,(e.current.flags&128)===128)}catch{}}var Me=Math.clz32?Math.clz32:Pf,Of=Math.log,Tf=Math.LN2;function Pf(e){return e>>>=0,e===0?32:31-(Of(e)/Tf|0)|0}var dr=64,pr=4194304;function Nn(e){switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return e&4194240;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return e&130023424;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;default:return e}}function Vr(e,t){var n=e.pendingLanes;if(n===0)return 0;var r=0,l=e.suspendedLanes,i=e.pingedLanes,o=n&268435455;if(o!==0){var u=o&~l;u!==0?r=Nn(u):(i&=o,i!==0&&(r=Nn(i)))}else o=n&~l,o!==0?r=Nn(o):i!==0&&(r=Nn(i));if(r===0)return 0;if(t!==0&&t!==r&&!(t&l)&&(l=r&-r,i=t&-t,l>=i||l===16&&(i&4194240)!==0))return t;if(r&4&&(r|=n&16),t=e.entangledLanes,t!==0)for(e=e.entanglements,t&=r;0<t;)n=31-Me(t),l=1<<n,r|=e[n],t&=~l;return r}function zf(e,t){switch(e){case 1:case 2:case 4:return t+250;case 8:case 16:case 32:case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return t+5e3;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return-1;case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function Lf(e,t){for(var n=e.suspendedLanes,r=e.pingedLanes,l=e.expirationTimes,i=e.pendingLanes;0<i;){var o=31-Me(i),u=1<<o,s=l[o];s===-1?(!(u&n)||u&r)&&(l[o]=zf(u,t)):s<=t&&(e.expiredLanes|=u),i&=~u}}function yi(e){return e=e.pendingLanes&-1073741825,e!==0?e:e&1073741824?1073741824:0}function As(){var e=dr;return dr<<=1,!(dr&4194240)&&(dr=64),e}function zl(e){for(var t=[],n=0;31>n;n++)t.push(e);return t}function nr(e,t,n){e.pendingLanes|=t,t!==536870912&&(e.suspendedLanes=0,e.pingedLanes=0),e=e.eventTimes,t=31-Me(t),e[t]=n}function If(e,t){var n=e.pendingLanes&~t;e.pendingLanes=t,e.suspendedLanes=0,e.pingedLanes=0,e.expiredLanes&=t,e.mutableReadLanes&=t,e.entangledLanes&=t,t=e.entanglements;var r=e.eventTimes;for(e=e.expirationTimes;0<n;){var l=31-Me(n),i=1<<l;t[l]=0,r[l]=-1,e[l]=-1,n&=~i}}function ro(e,t){var n=e.entangledLanes|=t;for(e=e.entanglements;n;){var r=31-Me(n),l=1<<r;l&t|e[r]&t&&(e[r]|=t),n&=~l}}var A=0;function Ms(e){return e&=-e,1<e?4<e?e&268435455?16:536870912:4:1}var Ds,lo,$s,Us,Vs,hi=!1,mr=[],st=null,at=null,ct=null,Vn=new Map,Bn=new Map,lt=[],Ff="mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(" ");function nu(e,t){switch(e){case"focusin":case"focusout":st=null;break;case"dragenter":case"dragleave":at=null;break;case"mouseover":case"mouseout":ct=null;break;case"pointerover":case"pointerout":Vn.delete(t.pointerId);break;case"gotpointercapture":case"lostpointercapture":Bn.delete(t.pointerId)}}function wn(e,t,n,r,l,i){return e===null||e.nativeEvent!==i?(e={blockedOn:t,domEventName:n,eventSystemFlags:r,nativeEvent:i,targetContainers:[l]},t!==null&&(t=lr(t),t!==null&&lo(t)),e):(e.eventSystemFlags|=r,t=e.targetContainers,l!==null&&t.indexOf(l)===-1&&t.push(l),e)}function Rf(e,t,n,r,l){switch(t){case"focusin":return st=wn(st,e,t,n,r,l),!0;case"dragenter":return at=wn(at,e,t,n,r,l),!0;case"mouseover":return ct=wn(ct,e,t,n,r,l),!0;case"pointerover":var i=l.pointerId;return Vn.set(i,wn(Vn.get(i)||null,e,t,n,r,l)),!0;case"gotpointercapture":return i=l.pointerId,Bn.set(i,wn(Bn.get(i)||null,e,t,n,r,l)),!0}return!1}function Bs(e){var t=jt(e.target);if(t!==null){var n=At(t);if(n!==null){if(t=n.tag,t===13){if(t=Ps(n),t!==null){e.blockedOn=t,Vs(e.priority,function(){$s(n)});return}}else if(t===3&&n.stateNode.current.memoizedState.isDehydrated){e.blockedOn=n.tag===3?n.stateNode.containerInfo:null;return}}}e.blockedOn=null}function Nr(e){if(e.blockedOn!==null)return!1;for(var t=e.targetContainers;0<t.length;){var n=vi(e.domEventName,e.eventSystemFlags,t[0],e.nativeEvent);if(n===null){n=e.nativeEvent;var r=new n.constructor(n.type,n);fi=r,n.target.dispatchEvent(r),fi=null}else return t=lr(n),t!==null&&lo(t),e.blockedOn=n,!1;t.shift()}return!0}function ru(e,t,n){Nr(e)&&n.delete(t)}function Af(){hi=!1,st!==null&&Nr(st)&&(st=null),at!==null&&Nr(at)&&(at=null),ct!==null&&Nr(ct)&&(ct=null),Vn.forEach(ru),Bn.forEach(ru)}function Sn(e,t){e.blockedOn===t&&(e.blockedOn=null,hi||(hi=!0,Ee.unstable_scheduleCallback(Ee.unstable_NormalPriority,Af)))}function Qn(e){function t(l){return Sn(l,e)}if(0<mr.length){Sn(mr[0],e);for(var n=1;n<mr.length;n++){var r=mr[n];r.blockedOn===e&&(r.blockedOn=null)}}for(st!==null&&Sn(st,e),at!==null&&Sn(at,e),ct!==null&&Sn(ct,e),Vn.forEach(t),Bn.forEach(t),n=0;n<lt.length;n++)r=lt[n],r.blockedOn===e&&(r.blockedOn=null);for(;0<lt.length&&(n=lt[0],n.blockedOn===null);)Bs(n),n.blockedOn===null&&lt.shift()}var bt=et.ReactCurrentBatchConfig,Br=!0;function Mf(e,t,n,r){var l=A,i=bt.transition;bt.transition=null;try{A=1,io(e,t,n,r)}finally{A=l,bt.transition=i}}function Df(e,t,n,r){var l=A,i=bt.transition;bt.transition=null;try{A=4,io(e,t,n,r)}finally{A=l,bt.transition=i}}function io(e,t,n,r){if(Br){var l=vi(e,t,n,r);if(l===null)Vl(e,t,r,Qr,n),nu(e,r);else if(Rf(l,e,t,n,r))r.stopPropagation();else if(nu(e,r),t&4&&-1<Ff.indexOf(e)){for(;l!==null;){var i=lr(l);if(i!==null&&Ds(i),i=vi(e,t,n,r),i===null&&Vl(e,t,r,Qr,n),i===l)break;l=i}l!==null&&r.stopPropagation()}else Vl(e,t,r,null,n)}}var Qr=null;function vi(e,t,n,r){if(Qr=null,e=to(r),e=jt(e),e!==null)if(t=At(e),t===null)e=null;else if(n=t.tag,n===13){if(e=Ps(t),e!==null)return e;e=null}else if(n===3){if(t.stateNode.current.memoizedState.isDehydrated)return t.tag===3?t.stateNode.containerInfo:null;e=null}else t!==e&&(e=null);return Qr=e,null}function Qs(e){switch(e){case"cancel":case"click":case"close":case"contextmenu":case"copy":case"cut":case"auxclick":case"dblclick":case"dragend":case"dragstart":case"drop":case"focusin":case"focusout":case"input":case"invalid":case"keydown":case"keypress":case"keyup":case"mousedown":case"mouseup":case"paste":case"pause":case"play":case"pointercancel":case"pointerdown":case"pointerup":case"ratechange":case"reset":case"resize":case"seeked":case"submit":case"touchcancel":case"touchend":case"touchstart":case"volumechange":case"change":case"selectionchange":case"textInput":case"compositionstart":case"compositionend":case"compositionupdate":case"beforeblur":case"afterblur":case"beforeinput":case"blur":case"fullscreenchange":case"focus":case"hashchange":case"popstate":case"select":case"selectstart":return 1;case"drag":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"mousemove":case"mouseout":case"mouseover":case"pointermove":case"pointerout":case"pointerover":case"scroll":case"toggle":case"touchmove":case"wheel":case"mouseenter":case"mouseleave":case"pointerenter":case"pointerleave":return 4;case"message":switch(jf()){case no:return 1;case Fs:return 4;case Ur:case _f:return 16;case Rs:return 536870912;default:return 16}default:return 16}}var ot=null,oo=null,Or=null;function Hs(){if(Or)return Or;var e,t=oo,n=t.length,r,l="value"in ot?ot.value:ot.textContent,i=l.length;for(e=0;e<n&&t[e]===l[e];e++);var o=n-e;for(r=1;r<=o&&t[n-r]===l[i-r];r++);return Or=l.slice(e,1<r?1-r:void 0)}function Tr(e){var t=e.keyCode;return"charCode"in e?(e=e.charCode,e===0&&t===13&&(e=13)):e=t,e===10&&(e=13),32<=e||e===13?e:0}function yr(){return!0}function lu(){return!1}function je(e){function t(n,r,l,i,o){this._reactName=n,this._targetInst=l,this.type=r,this.nativeEvent=i,this.target=o,this.currentTarget=null;for(var u in e)e.hasOwnProperty(u)&&(n=e[u],this[u]=n?n(i):i[u]);return this.isDefaultPrevented=(i.defaultPrevented!=null?i.defaultPrevented:i.returnValue===!1)?yr:lu,this.isPropagationStopped=lu,this}return H(t.prototype,{preventDefault:function(){this.defaultPrevented=!0;var n=this.nativeEvent;n&&(n.preventDefault?n.preventDefault():typeof n.returnValue!="unknown"&&(n.returnValue=!1),this.isDefaultPrevented=yr)},stopPropagation:function(){var n=this.nativeEvent;n&&(n.stopPropagation?n.stopPropagation():typeof n.cancelBubble!="unknown"&&(n.cancelBubble=!0),this.isPropagationStopped=yr)},persist:function(){},isPersistent:yr}),t}var fn={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(e){return e.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},uo=je(fn),rr=H({},fn,{view:0,detail:0}),$f=je(rr),Ll,Il,xn,al=H({},rr,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:so,button:0,buttons:0,relatedTarget:function(e){return e.relatedTarget===void 0?e.fromElement===e.srcElement?e.toElement:e.fromElement:e.relatedTarget},movementX:function(e){return"movementX"in e?e.movementX:(e!==xn&&(xn&&e.type==="mousemove"?(Ll=e.screenX-xn.screenX,Il=e.screenY-xn.screenY):Il=Ll=0,xn=e),Ll)},movementY:function(e){return"movementY"in e?e.movementY:Il}}),iu=je(al),Uf=H({},al,{dataTransfer:0}),Vf=je(Uf),Bf=H({},rr,{relatedTarget:0}),Fl=je(Bf),Qf=H({},fn,{animationName:0,elapsedTime:0,pseudoElement:0}),Hf=je(Qf),Wf=H({},fn,{clipboardData:function(e){return"clipboardData"in e?e.clipboardData:window.clipboardData}}),Kf=je(Wf),Yf=H({},fn,{data:0}),ou=je(Yf),Xf={Esc:"Escape",Spacebar:" ",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Win:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"Unidentified"},Gf={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:"Meta"},Zf={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};function qf(e){var t=this.nativeEvent;return t.getModifierState?t.getModifierState(e):(e=Zf[e])?!!t[e]:!1}function so(){return qf}var Jf=H({},rr,{key:function(e){if(e.key){var t=Xf[e.key]||e.key;if(t!=="Unidentified")return t}return e.type==="keypress"?(e=Tr(e),e===13?"Enter":String.fromCharCode(e)):e.type==="keydown"||e.type==="keyup"?Gf[e.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:so,charCode:function(e){return e.type==="keypress"?Tr(e):0},keyCode:function(e){return e.type==="keydown"||e.type==="keyup"?e.keyCode:0},which:function(e){return e.type==="keypress"?Tr(e):e.type==="keydown"||e.type==="keyup"?e.keyCode:0}}),bf=je(Jf),ed=H({},al,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),uu=je(ed),td=H({},rr,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:so}),nd=je(td),rd=H({},fn,{propertyName:0,elapsedTime:0,pseudoElement:0}),ld=je(rd),id=H({},al,{deltaX:function(e){return"deltaX"in e?e.deltaX:"wheelDeltaX"in e?-e.wheelDeltaX:0},deltaY:function(e){return"deltaY"in e?e.deltaY:"wheelDeltaY"in e?-e.wheelDeltaY:"wheelDelta"in e?-e.wheelDelta:0},deltaZ:0,deltaMode:0}),od=je(id),ud=[9,13,27,32],ao=Ze&&"CompositionEvent"in window,zn=null;Ze&&"documentMode"in document&&(zn=document.documentMode);var sd=Ze&&"TextEvent"in window&&!zn,Ws=Ze&&(!ao||zn&&8<zn&&11>=zn),su=String.fromCharCode(32),au=!1;function Ks(e,t){switch(e){case"keyup":return ud.indexOf(t.keyCode)!==-1;case"keydown":return t.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function Ys(e){return e=e.detail,typeof e=="object"&&"data"in e?e.data:null}var Ut=!1;function ad(e,t){switch(e){case"compositionend":return Ys(t);case"keypress":return t.which!==32?null:(au=!0,su);case"textInput":return e=t.data,e===su&&au?null:e;default:return null}}function cd(e,t){if(Ut)return e==="compositionend"||!ao&&Ks(e,t)?(e=Hs(),Or=oo=ot=null,Ut=!1,e):null;switch(e){case"paste":return null;case"keypress":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1<t.char.length)return t.char;if(t.which)return String.fromCharCode(t.which)}return null;case"compositionend":return Ws&&t.locale!=="ko"?null:t.data;default:return null}}var fd={color:!0,date:!0,datetime:!0,"datetime-local":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function cu(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t==="input"?!!fd[e.type]:t==="textarea"}function Xs(e,t,n,r){js(r),t=Hr(t,"onChange"),0<t.length&&(n=new uo("onChange","change",null,n,r),e.push({event:n,listeners:t}))}var Ln=null,Hn=null;function dd(e){ia(e,0)}function cl(e){var t=Qt(e);if(gs(t))return e}function pd(e,t){if(e==="change")return t}var Gs=!1;if(Ze){var Rl;if(Ze){var Al="oninput"in document;if(!Al){var fu=document.createElement("div");fu.setAttribute("oninput","return;"),Al=typeof fu.oninput=="function"}Rl=Al}else Rl=!1;Gs=Rl&&(!document.documentMode||9<document.documentMode)}function du(){Ln&&(Ln.detachEvent("onpropertychange",Zs),Hn=Ln=null)}function Zs(e){if(e.propertyName==="value"&&cl(Hn)){var t=[];Xs(t,Hn,e,to(e)),Ts(dd,t)}}function md(e,t,n){e==="focusin"?(du(),Ln=t,Hn=n,Ln.attachEvent("onpropertychange",Zs)):e==="focusout"&&du()}function yd(e){if(e==="selectionchange"||e==="keyup"||e==="keydown")return cl(Hn)}function hd(e,t){if(e==="click")return cl(t)}function vd(e,t){if(e==="input"||e==="change")return cl(t)}function gd(e,t){return e===t&&(e!==0||1/e===1/t)||e!==e&&t!==t}var $e=typeof Object.is=="function"?Object.is:gd;function Wn(e,t){if($e(e,t))return!0;if(typeof e!="object"||e===null||typeof t!="object"||t===null)return!1;var n=Object.keys(e),r=Object.keys(t);if(n.length!==r.length)return!1;for(r=0;r<n.length;r++){var l=n[r];if(!bl.call(t,l)||!$e(e[l],t[l]))return!1}return!0}function pu(e){for(;e&&e.firstChild;)e=e.firstChild;return e}function mu(e,t){var n=pu(e);e=0;for(var r;n;){if(n.nodeType===3){if(r=e+n.textContent.length,e<=t&&r>=t)return{node:n,offset:t-e};e=r}e:{for(;n;){if(n.nextSibling){n=n.nextSibling;break e}n=n.parentNode}n=void 0}n=pu(n)}}function qs(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?qs(e,t.parentNode):"contains"in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function Js(){for(var e=window,t=Mr();t instanceof e.HTMLIFrameElement;){try{var n=typeof t.contentWindow.location.href=="string"}catch{n=!1}if(n)e=t.contentWindow;else break;t=Mr(e.document)}return t}function co(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t==="input"&&(e.type==="text"||e.type==="search"||e.type==="tel"||e.type==="url"||e.type==="password")||t==="textarea"||e.contentEditable==="true")}function wd(e){var t=Js(),n=e.focusedElem,r=e.selectionRange;if(t!==n&&n&&n.ownerDocument&&qs(n.ownerDocument.documentElement,n)){if(r!==null&&co(n)){if(t=r.start,e=r.end,e===void 0&&(e=t),"selectionStart"in n)n.selectionStart=t,n.selectionEnd=Math.min(e,n.value.length);else if(e=(t=n.ownerDocument||document)&&t.defaultView||window,e.getSelection){e=e.getSelection();var l=n.textContent.length,i=Math.min(r.start,l);r=r.end===void 0?i:Math.min(r.end,l),!e.extend&&i>r&&(l=r,r=i,i=l),l=mu(n,i);var o=mu(n,r);l&&o&&(e.rangeCount!==1||e.anchorNode!==l.node||e.anchorOffset!==l.offset||e.focusNode!==o.node||e.focusOffset!==o.offset)&&(t=t.createRange(),t.setStart(l.node,l.offset),e.removeAllRanges(),i>r?(e.addRange(t),e.extend(o.node,o.offset)):(t.setEnd(o.node,o.offset),e.addRange(t)))}}for(t=[],e=n;e=e.parentNode;)e.nodeType===1&&t.push({element:e,left:e.scrollLeft,top:e.scrollTop});for(typeof n.focus=="function"&&n.focus(),n=0;n<t.length;n++)e=t[n],e.element.scrollLeft=e.left,e.element.scrollTop=e.top}}var Sd=Ze&&"documentMode"in document&&11>=document.documentMode,Vt=null,gi=null,In=null,wi=!1;function yu(e,t,n){var r=n.window===n?n.document:n.nodeType===9?n:n.ownerDocument;wi||Vt==null||Vt!==Mr(r)||(r=Vt,"selectionStart"in r&&co(r)?r={start:r.selectionStart,end:r.selectionEnd}:(r=(r.ownerDocument&&r.ownerDocument.defaultView||window).getSelection(),r={anchorNode:r.anchorNode,anchorOffset:r.anchorOffset,focusNode:r.focusNode,focusOffset:r.focusOffset}),In&&Wn(In,r)||(In=r,r=Hr(gi,"onSelect"),0<r.length&&(t=new uo("onSelect","select",null,t,n),e.push({event:t,listeners:r}),t.target=Vt)))}function hr(e,t){var n={};return n[e.toLowerCase()]=t.toLowerCase(),n["Webkit"+e]="webkit"+t,n["Moz"+e]="moz"+t,n}var Bt={animationend:hr("Animation","AnimationEnd"),animationiteration:hr("Animation","AnimationIteration"),animationstart:hr("Animation","AnimationStart"),transitionend:hr("Transition","TransitionEnd")},Ml={},bs={};Ze&&(bs=document.createElement("div").style,"AnimationEvent"in window||(delete Bt.animationend.animation,delete Bt.animationiteration.animation,delete Bt.animationstart.animation),"TransitionEvent"in window||delete Bt.transitionend.transition);function fl(e){if(Ml[e])return Ml[e];if(!Bt[e])return e;var t=Bt[e],n;for(n in t)if(t.hasOwnProperty(n)&&n in bs)return Ml[e]=t[n];return e}var ea=fl("animationend"),ta=fl("animationiteration"),na=fl("animationstart"),ra=fl("transitionend"),la=new Map,hu="abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");function gt(e,t){la.set(e,t),Rt(t,[e])}for(var Dl=0;Dl<hu.length;Dl++){var $l=hu[Dl],xd=$l.toLowerCase(),kd=$l[0].toUpperCase()+$l.slice(1);gt(xd,"on"+kd)}gt(ea,"onAnimationEnd");gt(ta,"onAnimationIteration");gt(na,"onAnimationStart");gt("dblclick","onDoubleClick");gt("focusin","onFocus");gt("focusout","onBlur");gt(ra,"onTransitionEnd");nn("onMouseEnter",["mouseout","mouseover"]);nn("onMouseLeave",["mouseout","mouseover"]);nn("onPointerEnter",["pointerout","pointerover"]);nn("onPointerLeave",["pointerout","pointerover"]);Rt("onChange","change click focusin focusout input keydown keyup selectionchange".split(" "));Rt("onSelect","focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" "));Rt("onBeforeInput",["compositionend","keypress","textInput","paste"]);Rt("onCompositionEnd","compositionend focusout keydown keypress keyup mousedown".split(" "));Rt("onCompositionStart","compositionstart focusout keydown keypress keyup mousedown".split(" "));Rt("onCompositionUpdate","compositionupdate focusout keydown keypress keyup mousedown".split(" "));var On="abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),Ed=new Set("cancel close invalid load scroll toggle".split(" ").concat(On));function vu(e,t,n){var r=e.type||"unknown-event";e.currentTarget=n,xf(r,t,void 0,e),e.currentTarget=null}function ia(e,t){t=(t&4)!==0;for(var n=0;n<e.length;n++){var r=e[n],l=r.event;r=r.listeners;e:{var i=void 0;if(t)for(var o=r.length-1;0<=o;o--){var u=r[o],s=u.instance,c=u.currentTarget;if(u=u.listener,s!==i&&l.isPropagationStopped())break e;vu(l,u,c),i=s}else for(o=0;o<r.length;o++){if(u=r[o],s=u.instance,c=u.currentTarget,u=u.listener,s!==i&&l.isPropagationStopped())break e;vu(l,u,c),i=s}}}if($r)throw e=mi,$r=!1,mi=null,e}function $(e,t){var n=t[Ci];n===void 0&&(n=t[Ci]=new Set);var r=e+"__bubble";n.has(r)||(oa(t,e,2,!1),n.add(r))}function Ul(e,t,n){var r=0;t&&(r|=4),oa(n,e,r,t)}var vr="_reactListening"+Math.random().toString(36).slice(2);function Kn(e){if(!e[vr]){e[vr]=!0,ps.forEach(function(n){n!=="selectionchange"&&(Ed.has(n)||Ul(n,!1,e),Ul(n,!0,e))});var t=e.nodeType===9?e:e.ownerDocument;t===null||t[vr]||(t[vr]=!0,Ul("selectionchange",!1,t))}}function oa(e,t,n,r){switch(Qs(t)){case 1:var l=Mf;break;case 4:l=Df;break;default:l=io}n=l.bind(null,t,n,e),l=void 0,!pi||t!=="touchstart"&&t!=="touchmove"&&t!=="wheel"||(l=!0),r?l!==void 0?e.addEventListener(t,n,{capture:!0,passive:l}):e.addEventListener(t,n,!0):l!==void 0?e.addEventListener(t,n,{passive:l}):e.addEventListener(t,n,!1)}function Vl(e,t,n,r,l){var i=r;if(!(t&1)&&!(t&2)&&r!==null)e:for(;;){if(r===null)return;var o=r.tag;if(o===3||o===4){var u=r.stateNode.containerInfo;if(u===l||u.nodeType===8&&u.parentNode===l)break;if(o===4)for(o=r.return;o!==null;){var s=o.tag;if((s===3||s===4)&&(s=o.stateNode.containerInfo,s===l||s.nodeType===8&&s.parentNode===l))return;o=o.return}for(;u!==null;){if(o=jt(u),o===null)return;if(s=o.tag,s===5||s===6){r=i=o;continue e}u=u.parentNode}}r=r.return}Ts(function(){var c=i,y=to(n),f=[];e:{var v=la.get(e);if(v!==void 0){var g=uo,w=e;switch(e){case"keypress":if(Tr(n)===0)break e;case"keydown":case"keyup":g=bf;break;case"focusin":w="focus",g=Fl;break;case"focusout":w="blur",g=Fl;break;case"beforeblur":case"afterblur":g=Fl;break;case"click":if(n.button===2)break e;case"auxclick":case"dblclick":case"mousedown":case"mousemove":case"mouseup":case"mouseout":case"mouseover":case"contextmenu":g=iu;break;case"drag":case"dragend":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"dragstart":case"drop":g=Vf;break;case"touchcancel":case"touchend":case"touchmove":case"touchstart":g=nd;break;case ea:case ta:case na:g=Hf;break;case ra:g=ld;break;case"scroll":g=$f;break;case"wheel":g=od;break;case"copy":case"cut":case"paste":g=Kf;break;case"gotpointercapture":case"lostpointercapture":case"pointercancel":case"pointerdown":case"pointermove":case"pointerout":case"pointerover":case"pointerup":g=uu}var k=(t&4)!==0,M=!k&&e==="scroll",p=k?v!==null?v+"Capture":null:v;k=[];for(var d=c,h;d!==null;){h=d;var S=h.stateNode;if(h.tag===5&&S!==null&&(h=S,p!==null&&(S=Un(d,p),S!=null&&k.push(Yn(d,S,h)))),M)break;d=d.return}0<k.length&&(v=new g(v,w,null,n,y),f.push({event:v,listeners:k}))}}if(!(t&7)){e:{if(v=e==="mouseover"||e==="pointerover",g=e==="mouseout"||e==="pointerout",v&&n!==fi&&(w=n.relatedTarget||n.fromElement)&&(jt(w)||w[qe]))break e;if((g||v)&&(v=y.window===y?y:(v=y.ownerDocument)?v.defaultView||v.parentWindow:window,g?(w=n.relatedTarget||n.toElement,g=c,w=w?jt(w):null,w!==null&&(M=At(w),w!==M||w.tag!==5&&w.tag!==6)&&(w=null)):(g=null,w=c),g!==w)){if(k=iu,S="onMouseLeave",p="onMouseEnter",d="mouse",(e==="pointerout"||e==="pointerover")&&(k=uu,S="onPointerLeave",p="onPointerEnter",d="pointer"),M=g==null?v:Qt(g),h=w==null?v:Qt(w),v=new k(S,d+"leave",g,n,y),v.target=M,v.relatedTarget=h,S=null,jt(y)===c&&(k=new k(p,d+"enter",w,n,y),k.target=h,k.relatedTarget=M,S=k),M=S,g&&w)t:{for(k=g,p=w,d=0,h=k;h;h=Mt(h))d++;for(h=0,S=p;S;S=Mt(S))h++;for(;0<d-h;)k=Mt(k),d--;for(;0<h-d;)p=Mt(p),h--;for(;d--;){if(k===p||p!==null&&k===p.alternate)break t;k=Mt(k),p=Mt(p)}k=null}else k=null;g!==null&&gu(f,v,g,k,!1),w!==null&&M!==null&&gu(f,M,w,k,!0)}}e:{if(v=c?Qt(c):window,g=v.nodeName&&v.nodeName.toLowerCase(),g==="select"||g==="input"&&v.type==="file")var C=pd;else if(cu(v))if(Gs)C=vd;else{C=yd;var _=md}else(g=v.nodeName)&&g.toLowerCase()==="input"&&(v.type==="checkbox"||v.type==="radio")&&(C=hd);if(C&&(C=C(e,c))){Xs(f,C,n,y);break e}_&&_(e,v,c),e==="focusout"&&(_=v._wrapperState)&&_.controlled&&v.type==="number"&&oi(v,"number",v.value)}switch(_=c?Qt(c):window,e){case"focusin":(cu(_)||_.contentEditable==="true")&&(Vt=_,gi=c,In=null);break;case"focusout":In=gi=Vt=null;break;case"mousedown":wi=!0;break;case"contextmenu":case"mouseup":case"dragend":wi=!1,yu(f,n,y);break;case"selectionchange":if(Sd)break;case"keydown":case"keyup":yu(f,n,y)}var N;if(ao)e:{switch(e){case"compositionstart":var O="onCompositionStart";break e;case"compositionend":O="onCompositionEnd";break e;case"compositionupdate":O="onCompositionUpdate";break e}O=void 0}else Ut?Ks(e,n)&&(O="onCompositionEnd"):e==="keydown"&&n.keyCode===229&&(O="onCompositionStart");O&&(Ws&&n.locale!=="ko"&&(Ut||O!=="onCompositionStart"?O==="onCompositionEnd"&&Ut&&(N=Hs()):(ot=y,oo="value"in ot?ot.value:ot.textContent,Ut=!0)),_=Hr(c,O),0<_.length&&(O=new ou(O,e,null,n,y),f.push({event:O,listeners:_}),N?O.data=N:(N=Ys(n),N!==null&&(O.data=N)))),(N=sd?ad(e,n):cd(e,n))&&(c=Hr(c,"onBeforeInput"),0<c.length&&(y=new ou("onBeforeInput","beforeinput",null,n,y),f.push({event:y,listeners:c}),y.data=N))}ia(f,t)})}function Yn(e,t,n){return{instance:e,listener:t,currentTarget:n}}function Hr(e,t){for(var n=t+"Capture",r=[];e!==null;){var l=e,i=l.stateNode;l.tag===5&&i!==null&&(l=i,i=Un(e,n),i!=null&&r.unshift(Yn(e,i,l)),i=Un(e,t),i!=null&&r.push(Yn(e,i,l))),e=e.return}return r}function Mt(e){if(e===null)return null;do e=e.return;while(e&&e.tag!==5);return e||null}function gu(e,t,n,r,l){for(var i=t._reactName,o=[];n!==null&&n!==r;){var u=n,s=u.alternate,c=u.stateNode;if(s!==null&&s===r)break;u.tag===5&&c!==null&&(u=c,l?(s=Un(n,i),s!=null&&o.unshift(Yn(n,s,u))):l||(s=Un(n,i),s!=null&&o.push(Yn(n,s,u)))),n=n.return}o.length!==0&&e.push({event:t,listeners:o})}var Cd=/\r\n?/g,jd=/\u0000|\uFFFD/g;function wu(e){return(typeof e=="string"?e:""+e).replace(Cd,`
-`).replace(jd,"")}function gr(e,t,n){if(t=wu(t),wu(e)!==t&&n)throw Error(x(425))}function Wr(){}var Si=null,xi=null;function ki(e,t){return e==="textarea"||e==="noscript"||typeof t.children=="string"||typeof t.children=="number"||typeof t.dangerouslySetInnerHTML=="object"&&t.dangerouslySetInnerHTML!==null&&t.dangerouslySetInnerHTML.__html!=null}var Ei=typeof setTimeout=="function"?setTimeout:void 0,_d=typeof clearTimeout=="function"?clearTimeout:void 0,Su=typeof Promise=="function"?Promise:void 0,Nd=typeof queueMicrotask=="function"?queueMicrotask:typeof Su<"u"?function(e){return Su.resolve(null).then(e).catch(Od)}:Ei;function Od(e){setTimeout(function(){throw e})}function Bl(e,t){var n=t,r=0;do{var l=n.nextSibling;if(e.removeChild(n),l&&l.nodeType===8)if(n=l.data,n==="/$"){if(r===0){e.removeChild(l),Qn(t);return}r--}else n!=="$"&&n!=="$?"&&n!=="$!"||r++;n=l}while(n);Qn(t)}function ft(e){for(;e!=null;e=e.nextSibling){var t=e.nodeType;if(t===1||t===3)break;if(t===8){if(t=e.data,t==="$"||t==="$!"||t==="$?")break;if(t==="/$")return null}}return e}function xu(e){e=e.previousSibling;for(var t=0;e;){if(e.nodeType===8){var n=e.data;if(n==="$"||n==="$!"||n==="$?"){if(t===0)return e;t--}else n==="/$"&&t++}e=e.previousSibling}return null}var dn=Math.random().toString(36).slice(2),Be="__reactFiber$"+dn,Xn="__reactProps$"+dn,qe="__reactContainer$"+dn,Ci="__reactEvents$"+dn,Td="__reactListeners$"+dn,Pd="__reactHandles$"+dn;function jt(e){var t=e[Be];if(t)return t;for(var n=e.parentNode;n;){if(t=n[qe]||n[Be]){if(n=t.alternate,t.child!==null||n!==null&&n.child!==null)for(e=xu(e);e!==null;){if(n=e[Be])return n;e=xu(e)}return t}e=n,n=e.parentNode}return null}function lr(e){return e=e[Be]||e[qe],!e||e.tag!==5&&e.tag!==6&&e.tag!==13&&e.tag!==3?null:e}function Qt(e){if(e.tag===5||e.tag===6)return e.stateNode;throw Error(x(33))}function dl(e){return e[Xn]||null}var ji=[],Ht=-1;function wt(e){return{current:e}}function U(e){0>Ht||(e.current=ji[Ht],ji[Ht]=null,Ht--)}function D(e,t){Ht++,ji[Ht]=e.current,e.current=t}var vt={},ce=wt(vt),ve=wt(!1),Pt=vt;function rn(e,t){var n=e.type.contextTypes;if(!n)return vt;var r=e.stateNode;if(r&&r.__reactInternalMemoizedUnmaskedChildContext===t)return r.__reactInternalMemoizedMaskedChildContext;var l={},i;for(i in n)l[i]=t[i];return r&&(e=e.stateNode,e.__reactInternalMemoizedUnmaskedChildContext=t,e.__reactInternalMemoizedMaskedChildContext=l),l}function ge(e){return e=e.childContextTypes,e!=null}function Kr(){U(ve),U(ce)}function ku(e,t,n){if(ce.current!==vt)throw Error(x(168));D(ce,t),D(ve,n)}function ua(e,t,n){var r=e.stateNode;if(t=t.childContextTypes,typeof r.getChildContext!="function")return n;r=r.getChildContext();for(var l in r)if(!(l in t))throw Error(x(108,mf(e)||"Unknown",l));return H({},n,r)}function Yr(e){return e=(e=e.stateNode)&&e.__reactInternalMemoizedMergedChildContext||vt,Pt=ce.current,D(ce,e),D(ve,ve.current),!0}function Eu(e,t,n){var r=e.stateNode;if(!r)throw Error(x(169));n?(e=ua(e,t,Pt),r.__reactInternalMemoizedMergedChildContext=e,U(ve),U(ce),D(ce,e)):U(ve),D(ve,n)}var Ke=null,pl=!1,Ql=!1;function sa(e){Ke===null?Ke=[e]:Ke.push(e)}function zd(e){pl=!0,sa(e)}function St(){if(!Ql&&Ke!==null){Ql=!0;var e=0,t=A;try{var n=Ke;for(A=1;e<n.length;e++){var r=n[e];do r=r(!0);while(r!==null)}Ke=null,pl=!1}catch(l){throw Ke!==null&&(Ke=Ke.slice(e+1)),Is(no,St),l}finally{A=t,Ql=!1}}return null}var Wt=[],Kt=0,Xr=null,Gr=0,_e=[],Ne=0,zt=null,Ye=1,Xe="";function Et(e,t){Wt[Kt++]=Gr,Wt[Kt++]=Xr,Xr=e,Gr=t}function aa(e,t,n){_e[Ne++]=Ye,_e[Ne++]=Xe,_e[Ne++]=zt,zt=e;var r=Ye;e=Xe;var l=32-Me(r)-1;r&=~(1<<l),n+=1;var i=32-Me(t)+l;if(30<i){var o=l-l%5;i=(r&(1<<o)-1).toString(32),r>>=o,l-=o,Ye=1<<32-Me(t)+l|n<<l|r,Xe=i+e}else Ye=1<<i|n<<l|r,Xe=e}function fo(e){e.return!==null&&(Et(e,1),aa(e,1,0))}function po(e){for(;e===Xr;)Xr=Wt[--Kt],Wt[Kt]=null,Gr=Wt[--Kt],Wt[Kt]=null;for(;e===zt;)zt=_e[--Ne],_e[Ne]=null,Xe=_e[--Ne],_e[Ne]=null,Ye=_e[--Ne],_e[Ne]=null}var ke=null,xe=null,V=!1,Ae=null;function ca(e,t){var n=Oe(5,null,null,0);n.elementType="DELETED",n.stateNode=t,n.return=e,t=e.deletions,t===null?(e.deletions=[n],e.flags|=16):t.push(n)}function Cu(e,t){switch(e.tag){case 5:var n=e.type;return t=t.nodeType!==1||n.toLowerCase()!==t.nodeName.toLowerCase()?null:t,t!==null?(e.stateNode=t,ke=e,xe=ft(t.firstChild),!0):!1;case 6:return t=e.pendingProps===""||t.nodeType!==3?null:t,t!==null?(e.stateNode=t,ke=e,xe=null,!0):!1;case 13:return t=t.nodeType!==8?null:t,t!==null?(n=zt!==null?{id:Ye,overflow:Xe}:null,e.memoizedState={dehydrated:t,treeContext:n,retryLane:1073741824},n=Oe(18,null,null,0),n.stateNode=t,n.return=e,e.child=n,ke=e,xe=null,!0):!1;default:return!1}}function _i(e){return(e.mode&1)!==0&&(e.flags&128)===0}function Ni(e){if(V){var t=xe;if(t){var n=t;if(!Cu(e,t)){if(_i(e))throw Error(x(418));t=ft(n.nextSibling);var r=ke;t&&Cu(e,t)?ca(r,n):(e.flags=e.flags&-4097|2,V=!1,ke=e)}}else{if(_i(e))throw Error(x(418));e.flags=e.flags&-4097|2,V=!1,ke=e}}}function ju(e){for(e=e.return;e!==null&&e.tag!==5&&e.tag!==3&&e.tag!==13;)e=e.return;ke=e}function wr(e){if(e!==ke)return!1;if(!V)return ju(e),V=!0,!1;var t;if((t=e.tag!==3)&&!(t=e.tag!==5)&&(t=e.type,t=t!=="head"&&t!=="body"&&!ki(e.type,e.memoizedProps)),t&&(t=xe)){if(_i(e))throw fa(),Error(x(418));for(;t;)ca(e,t),t=ft(t.nextSibling)}if(ju(e),e.tag===13){if(e=e.memoizedState,e=e!==null?e.dehydrated:null,!e)throw Error(x(317));e:{for(e=e.nextSibling,t=0;e;){if(e.nodeType===8){var n=e.data;if(n==="/$"){if(t===0){xe=ft(e.nextSibling);break e}t--}else n!=="$"&&n!=="$!"&&n!=="$?"||t++}e=e.nextSibling}xe=null}}else xe=ke?ft(e.stateNode.nextSibling):null;return!0}function fa(){for(var e=xe;e;)e=ft(e.nextSibling)}function ln(){xe=ke=null,V=!1}function mo(e){Ae===null?Ae=[e]:Ae.push(e)}var Ld=et.ReactCurrentBatchConfig;function Fe(e,t){if(e&&e.defaultProps){t=H({},t),e=e.defaultProps;for(var n in e)t[n]===void 0&&(t[n]=e[n]);return t}return t}var Zr=wt(null),qr=null,Yt=null,yo=null;function ho(){yo=Yt=qr=null}function vo(e){var t=Zr.current;U(Zr),e._currentValue=t}function Oi(e,t,n){for(;e!==null;){var r=e.alternate;if((e.childLanes&t)!==t?(e.childLanes|=t,r!==null&&(r.childLanes|=t)):r!==null&&(r.childLanes&t)!==t&&(r.childLanes|=t),e===n)break;e=e.return}}function en(e,t){qr=e,yo=Yt=null,e=e.dependencies,e!==null&&e.firstContext!==null&&(e.lanes&t&&(he=!0),e.firstContext=null)}function Pe(e){var t=e._currentValue;if(yo!==e)if(e={context:e,memoizedValue:t,next:null},Yt===null){if(qr===null)throw Error(x(308));Yt=e,qr.dependencies={lanes:0,firstContext:e}}else Yt=Yt.next=e;return t}var _t=null;function go(e){_t===null?_t=[e]:_t.push(e)}function da(e,t,n,r){var l=t.interleaved;return l===null?(n.next=n,go(t)):(n.next=l.next,l.next=n),t.interleaved=n,Je(e,r)}function Je(e,t){e.lanes|=t;var n=e.alternate;for(n!==null&&(n.lanes|=t),n=e,e=e.return;e!==null;)e.childLanes|=t,n=e.alternate,n!==null&&(n.childLanes|=t),n=e,e=e.return;return n.tag===3?n.stateNode:null}var rt=!1;function wo(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null}}function pa(e,t){e=e.updateQueue,t.updateQueue===e&&(t.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,effects:e.effects})}function Ge(e,t){return{eventTime:e,lane:t,tag:0,payload:null,callback:null,next:null}}function dt(e,t,n){var r=e.updateQueue;if(r===null)return null;if(r=r.shared,R&2){var l=r.pending;return l===null?t.next=t:(t.next=l.next,l.next=t),r.pending=t,Je(e,n)}return l=r.interleaved,l===null?(t.next=t,go(r)):(t.next=l.next,l.next=t),r.interleaved=t,Je(e,n)}function Pr(e,t,n){if(t=t.updateQueue,t!==null&&(t=t.shared,(n&4194240)!==0)){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,ro(e,n)}}function _u(e,t){var n=e.updateQueue,r=e.alternate;if(r!==null&&(r=r.updateQueue,n===r)){var l=null,i=null;if(n=n.firstBaseUpdate,n!==null){do{var o={eventTime:n.eventTime,lane:n.lane,tag:n.tag,payload:n.payload,callback:n.callback,next:null};i===null?l=i=o:i=i.next=o,n=n.next}while(n!==null);i===null?l=i=t:i=i.next=t}else l=i=t;n={baseState:r.baseState,firstBaseUpdate:l,lastBaseUpdate:i,shared:r.shared,effects:r.effects},e.updateQueue=n;return}e=n.lastBaseUpdate,e===null?n.firstBaseUpdate=t:e.next=t,n.lastBaseUpdate=t}function Jr(e,t,n,r){var l=e.updateQueue;rt=!1;var i=l.firstBaseUpdate,o=l.lastBaseUpdate,u=l.shared.pending;if(u!==null){l.shared.pending=null;var s=u,c=s.next;s.next=null,o===null?i=c:o.next=c,o=s;var y=e.alternate;y!==null&&(y=y.updateQueue,u=y.lastBaseUpdate,u!==o&&(u===null?y.firstBaseUpdate=c:u.next=c,y.lastBaseUpdate=s))}if(i!==null){var f=l.baseState;o=0,y=c=s=null,u=i;do{var v=u.lane,g=u.eventTime;if((r&v)===v){y!==null&&(y=y.next={eventTime:g,lane:0,tag:u.tag,payload:u.payload,callback:u.callback,next:null});e:{var w=e,k=u;switch(v=t,g=n,k.tag){case 1:if(w=k.payload,typeof w=="function"){f=w.call(g,f,v);break e}f=w;break e;case 3:w.flags=w.flags&-65537|128;case 0:if(w=k.payload,v=typeof w=="function"?w.call(g,f,v):w,v==null)break e;f=H({},f,v);break e;case 2:rt=!0}}u.callback!==null&&u.lane!==0&&(e.flags|=64,v=l.effects,v===null?l.effects=[u]:v.push(u))}else g={eventTime:g,lane:v,tag:u.tag,payload:u.payload,callback:u.callback,next:null},y===null?(c=y=g,s=f):y=y.next=g,o|=v;if(u=u.next,u===null){if(u=l.shared.pending,u===null)break;v=u,u=v.next,v.next=null,l.lastBaseUpdate=v,l.shared.pending=null}}while(1);if(y===null&&(s=f),l.baseState=s,l.firstBaseUpdate=c,l.lastBaseUpdate=y,t=l.shared.interleaved,t!==null){l=t;do o|=l.lane,l=l.next;while(l!==t)}else i===null&&(l.shared.lanes=0);It|=o,e.lanes=o,e.memoizedState=f}}function Nu(e,t,n){if(e=t.effects,t.effects=null,e!==null)for(t=0;t<e.length;t++){var r=e[t],l=r.callback;if(l!==null){if(r.callback=null,r=n,typeof l!="function")throw Error(x(191,l));l.call(r)}}}var ma=new ds.Component().refs;function Ti(e,t,n,r){t=e.memoizedState,n=n(r,t),n=n==null?t:H({},t,n),e.memoizedState=n,e.lanes===0&&(e.updateQueue.baseState=n)}var ml={isMounted:function(e){return(e=e._reactInternals)?At(e)===e:!1},enqueueSetState:function(e,t,n){e=e._reactInternals;var r=de(),l=mt(e),i=Ge(r,l);i.payload=t,n!=null&&(i.callback=n),t=dt(e,i,l),t!==null&&(De(t,e,l,r),Pr(t,e,l))},enqueueReplaceState:function(e,t,n){e=e._reactInternals;var r=de(),l=mt(e),i=Ge(r,l);i.tag=1,i.payload=t,n!=null&&(i.callback=n),t=dt(e,i,l),t!==null&&(De(t,e,l,r),Pr(t,e,l))},enqueueForceUpdate:function(e,t){e=e._reactInternals;var n=de(),r=mt(e),l=Ge(n,r);l.tag=2,t!=null&&(l.callback=t),t=dt(e,l,r),t!==null&&(De(t,e,r,n),Pr(t,e,r))}};function Ou(e,t,n,r,l,i,o){return e=e.stateNode,typeof e.shouldComponentUpdate=="function"?e.shouldComponentUpdate(r,i,o):t.prototype&&t.prototype.isPureReactComponent?!Wn(n,r)||!Wn(l,i):!0}function ya(e,t,n){var r=!1,l=vt,i=t.contextType;return typeof i=="object"&&i!==null?i=Pe(i):(l=ge(t)?Pt:ce.current,r=t.contextTypes,i=(r=r!=null)?rn(e,l):vt),t=new t(n,i),e.memoizedState=t.state!==null&&t.state!==void 0?t.state:null,t.updater=ml,e.stateNode=t,t._reactInternals=e,r&&(e=e.stateNode,e.__reactInternalMemoizedUnmaskedChildContext=l,e.__reactInternalMemoizedMaskedChildContext=i),t}function Tu(e,t,n,r){e=t.state,typeof t.componentWillReceiveProps=="function"&&t.componentWillReceiveProps(n,r),typeof t.UNSAFE_componentWillReceiveProps=="function"&&t.UNSAFE_componentWillReceiveProps(n,r),t.state!==e&&ml.enqueueReplaceState(t,t.state,null)}function Pi(e,t,n,r){var l=e.stateNode;l.props=n,l.state=e.memoizedState,l.refs=ma,wo(e);var i=t.contextType;typeof i=="object"&&i!==null?l.context=Pe(i):(i=ge(t)?Pt:ce.current,l.context=rn(e,i)),l.state=e.memoizedState,i=t.getDerivedStateFromProps,typeof i=="function"&&(Ti(e,t,i,n),l.state=e.memoizedState),typeof t.getDerivedStateFromProps=="function"||typeof l.getSnapshotBeforeUpdate=="function"||typeof l.UNSAFE_componentWillMount!="function"&&typeof l.componentWillMount!="function"||(t=l.state,typeof l.componentWillMount=="function"&&l.componentWillMount(),typeof l.UNSAFE_componentWillMount=="function"&&l.UNSAFE_componentWillMount(),t!==l.state&&ml.enqueueReplaceState(l,l.state,null),Jr(e,n,l,r),l.state=e.memoizedState),typeof l.componentDidMount=="function"&&(e.flags|=4194308)}function kn(e,t,n){if(e=n.ref,e!==null&&typeof e!="function"&&typeof e!="object"){if(n._owner){if(n=n._owner,n){if(n.tag!==1)throw Error(x(309));var r=n.stateNode}if(!r)throw Error(x(147,e));var l=r,i=""+e;return t!==null&&t.ref!==null&&typeof t.ref=="function"&&t.ref._stringRef===i?t.ref:(t=function(o){var u=l.refs;u===ma&&(u=l.refs={}),o===null?delete u[i]:u[i]=o},t._stringRef=i,t)}if(typeof e!="string")throw Error(x(284));if(!n._owner)throw Error(x(290,e))}return e}function Sr(e,t){throw e=Object.prototype.toString.call(t),Error(x(31,e==="[object Object]"?"object with keys {"+Object.keys(t).join(", ")+"}":e))}function Pu(e){var t=e._init;return t(e._payload)}function ha(e){function t(p,d){if(e){var h=p.deletions;h===null?(p.deletions=[d],p.flags|=16):h.push(d)}}function n(p,d){if(!e)return null;for(;d!==null;)t(p,d),d=d.sibling;return null}function r(p,d){for(p=new Map;d!==null;)d.key!==null?p.set(d.key,d):p.set(d.index,d),d=d.sibling;return p}function l(p,d){return p=yt(p,d),p.index=0,p.sibling=null,p}function i(p,d,h){return p.index=h,e?(h=p.alternate,h!==null?(h=h.index,h<d?(p.flags|=2,d):h):(p.flags|=2,d)):(p.flags|=1048576,d)}function o(p){return e&&p.alternate===null&&(p.flags|=2),p}function u(p,d,h,S){return d===null||d.tag!==6?(d=Zl(h,p.mode,S),d.return=p,d):(d=l(d,h),d.return=p,d)}function s(p,d,h,S){var C=h.type;return C===$t?y(p,d,h.props.children,S,h.key):d!==null&&(d.elementType===C||typeof C=="object"&&C!==null&&C.$$typeof===nt&&Pu(C)===d.type)?(S=l(d,h.props),S.ref=kn(p,d,h),S.return=p,S):(S=Ar(h.type,h.key,h.props,null,p.mode,S),S.ref=kn(p,d,h),S.return=p,S)}function c(p,d,h,S){return d===null||d.tag!==4||d.stateNode.containerInfo!==h.containerInfo||d.stateNode.implementation!==h.implementation?(d=ql(h,p.mode,S),d.return=p,d):(d=l(d,h.children||[]),d.return=p,d)}function y(p,d,h,S,C){return d===null||d.tag!==7?(d=Tt(h,p.mode,S,C),d.return=p,d):(d=l(d,h),d.return=p,d)}function f(p,d,h){if(typeof d=="string"&&d!==""||typeof d=="number")return d=Zl(""+d,p.mode,h),d.return=p,d;if(typeof d=="object"&&d!==null){switch(d.$$typeof){case ar:return h=Ar(d.type,d.key,d.props,null,p.mode,h),h.ref=kn(p,null,d),h.return=p,h;case Dt:return d=ql(d,p.mode,h),d.return=p,d;case nt:var S=d._init;return f(p,S(d._payload),h)}if(_n(d)||vn(d))return d=Tt(d,p.mode,h,null),d.return=p,d;Sr(p,d)}return null}function v(p,d,h,S){var C=d!==null?d.key:null;if(typeof h=="string"&&h!==""||typeof h=="number")return C!==null?null:u(p,d,""+h,S);if(typeof h=="object"&&h!==null){switch(h.$$typeof){case ar:return h.key===C?s(p,d,h,S):null;case Dt:return h.key===C?c(p,d,h,S):null;case nt:return C=h._init,v(p,d,C(h._payload),S)}if(_n(h)||vn(h))return C!==null?null:y(p,d,h,S,null);Sr(p,h)}return null}function g(p,d,h,S,C){if(typeof S=="string"&&S!==""||typeof S=="number")return p=p.get(h)||null,u(d,p,""+S,C);if(typeof S=="object"&&S!==null){switch(S.$$typeof){case ar:return p=p.get(S.key===null?h:S.key)||null,s(d,p,S,C);case Dt:return p=p.get(S.key===null?h:S.key)||null,c(d,p,S,C);case nt:var _=S._init;return g(p,d,h,_(S._payload),C)}if(_n(S)||vn(S))return p=p.get(h)||null,y(d,p,S,C,null);Sr(d,S)}return null}function w(p,d,h,S){for(var C=null,_=null,N=d,O=d=0,Y=null;N!==null&&O<h.length;O++){N.index>O?(Y=N,N=null):Y=N.sibling;var F=v(p,N,h[O],S);if(F===null){N===null&&(N=Y);break}e&&N&&F.alternate===null&&t(p,N),d=i(F,d,O),_===null?C=F:_.sibling=F,_=F,N=Y}if(O===h.length)return n(p,N),V&&Et(p,O),C;if(N===null){for(;O<h.length;O++)N=f(p,h[O],S),N!==null&&(d=i(N,d,O),_===null?C=N:_.sibling=N,_=N);return V&&Et(p,O),C}for(N=r(p,N);O<h.length;O++)Y=g(N,p,O,h[O],S),Y!==null&&(e&&Y.alternate!==null&&N.delete(Y.key===null?O:Y.key),d=i(Y,d,O),_===null?C=Y:_.sibling=Y,_=Y);return e&&N.forEach(function(Le){return t(p,Le)}),V&&Et(p,O),C}function k(p,d,h,S){var C=vn(h);if(typeof C!="function")throw Error(x(150));if(h=C.call(h),h==null)throw Error(x(151));for(var _=C=null,N=d,O=d=0,Y=null,F=h.next();N!==null&&!F.done;O++,F=h.next()){N.index>O?(Y=N,N=null):Y=N.sibling;var Le=v(p,N,F.value,S);if(Le===null){N===null&&(N=Y);break}e&&N&&Le.alternate===null&&t(p,N),d=i(Le,d,O),_===null?C=Le:_.sibling=Le,_=Le,N=Y}if(F.done)return n(p,N),V&&Et(p,O),C;if(N===null){for(;!F.done;O++,F=h.next())F=f(p,F.value,S),F!==null&&(d=i(F,d,O),_===null?C=F:_.sibling=F,_=F);return V&&Et(p,O),C}for(N=r(p,N);!F.done;O++,F=h.next())F=g(N,p,O,F.value,S),F!==null&&(e&&F.alternate!==null&&N.delete(F.key===null?O:F.key),d=i(F,d,O),_===null?C=F:_.sibling=F,_=F);return e&&N.forEach(function(mn){return t(p,mn)}),V&&Et(p,O),C}function M(p,d,h,S){if(typeof h=="object"&&h!==null&&h.type===$t&&h.key===null&&(h=h.props.children),typeof h=="object"&&h!==null){switch(h.$$typeof){case ar:e:{for(var C=h.key,_=d;_!==null;){if(_.key===C){if(C=h.type,C===$t){if(_.tag===7){n(p,_.sibling),d=l(_,h.props.children),d.return=p,p=d;break e}}else if(_.elementType===C||typeof C=="object"&&C!==null&&C.$$typeof===nt&&Pu(C)===_.type){n(p,_.sibling),d=l(_,h.props),d.ref=kn(p,_,h),d.return=p,p=d;break e}n(p,_);break}else t(p,_);_=_.sibling}h.type===$t?(d=Tt(h.props.children,p.mode,S,h.key),d.return=p,p=d):(S=Ar(h.type,h.key,h.props,null,p.mode,S),S.ref=kn(p,d,h),S.return=p,p=S)}return o(p);case Dt:e:{for(_=h.key;d!==null;){if(d.key===_)if(d.tag===4&&d.stateNode.containerInfo===h.containerInfo&&d.stateNode.implementation===h.implementation){n(p,d.sibling),d=l(d,h.children||[]),d.return=p,p=d;break e}else{n(p,d);break}else t(p,d);d=d.sibling}d=ql(h,p.mode,S),d.return=p,p=d}return o(p);case nt:return _=h._init,M(p,d,_(h._payload),S)}if(_n(h))return w(p,d,h,S);if(vn(h))return k(p,d,h,S);Sr(p,h)}return typeof h=="string"&&h!==""||typeof h=="number"?(h=""+h,d!==null&&d.tag===6?(n(p,d.sibling),d=l(d,h),d.return=p,p=d):(n(p,d),d=Zl(h,p.mode,S),d.return=p,p=d),o(p)):n(p,d)}return M}var on=ha(!0),va=ha(!1),ir={},He=wt(ir),Gn=wt(ir),Zn=wt(ir);function Nt(e){if(e===ir)throw Error(x(174));return e}function So(e,t){switch(D(Zn,t),D(Gn,e),D(He,ir),e=t.nodeType,e){case 9:case 11:t=(t=t.documentElement)?t.namespaceURI:si(null,"");break;default:e=e===8?t.parentNode:t,t=e.namespaceURI||null,e=e.tagName,t=si(t,e)}U(He),D(He,t)}function un(){U(He),U(Gn),U(Zn)}function ga(e){Nt(Zn.current);var t=Nt(He.current),n=si(t,e.type);t!==n&&(D(Gn,e),D(He,n))}function xo(e){Gn.current===e&&(U(He),U(Gn))}var B=wt(0);function br(e){for(var t=e;t!==null;){if(t.tag===13){var n=t.memoizedState;if(n!==null&&(n=n.dehydrated,n===null||n.data==="$?"||n.data==="$!"))return t}else if(t.tag===19&&t.memoizedProps.revealOrder!==void 0){if(t.flags&128)return t}else if(t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return null;t=t.return}t.sibling.return=t.return,t=t.sibling}return null}var Hl=[];function ko(){for(var e=0;e<Hl.length;e++)Hl[e]._workInProgressVersionPrimary=null;Hl.length=0}var zr=et.ReactCurrentDispatcher,Wl=et.ReactCurrentBatchConfig,Lt=0,Q=null,J=null,ne=null,el=!1,Fn=!1,qn=0,Id=0;function ue(){throw Error(x(321))}function Eo(e,t){if(t===null)return!1;for(var n=0;n<t.length&&n<e.length;n++)if(!$e(e[n],t[n]))return!1;return!0}function Co(e,t,n,r,l,i){if(Lt=i,Q=t,t.memoizedState=null,t.updateQueue=null,t.lanes=0,zr.current=e===null||e.memoizedState===null?Md:Dd,e=n(r,l),Fn){i=0;do{if(Fn=!1,qn=0,25<=i)throw Error(x(301));i+=1,ne=J=null,t.updateQueue=null,zr.current=$d,e=n(r,l)}while(Fn)}if(zr.current=tl,t=J!==null&&J.next!==null,Lt=0,ne=J=Q=null,el=!1,t)throw Error(x(300));return e}function jo(){var e=qn!==0;return qn=0,e}function Ve(){var e={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};return ne===null?Q.memoizedState=ne=e:ne=ne.next=e,ne}function ze(){if(J===null){var e=Q.alternate;e=e!==null?e.memoizedState:null}else e=J.next;var t=ne===null?Q.memoizedState:ne.next;if(t!==null)ne=t,J=e;else{if(e===null)throw Error(x(310));J=e,e={memoizedState:J.memoizedState,baseState:J.baseState,baseQueue:J.baseQueue,queue:J.queue,next:null},ne===null?Q.memoizedState=ne=e:ne=ne.next=e}return ne}function Jn(e,t){return typeof t=="function"?t(e):t}function Kl(e){var t=ze(),n=t.queue;if(n===null)throw Error(x(311));n.lastRenderedReducer=e;var r=J,l=r.baseQueue,i=n.pending;if(i!==null){if(l!==null){var o=l.next;l.next=i.next,i.next=o}r.baseQueue=l=i,n.pending=null}if(l!==null){i=l.next,r=r.baseState;var u=o=null,s=null,c=i;do{var y=c.lane;if((Lt&y)===y)s!==null&&(s=s.next={lane:0,action:c.action,hasEagerState:c.hasEagerState,eagerState:c.eagerState,next:null}),r=c.hasEagerState?c.eagerState:e(r,c.action);else{var f={lane:y,action:c.action,hasEagerState:c.hasEagerState,eagerState:c.eagerState,next:null};s===null?(u=s=f,o=r):s=s.next=f,Q.lanes|=y,It|=y}c=c.next}while(c!==null&&c!==i);s===null?o=r:s.next=u,$e(r,t.memoizedState)||(he=!0),t.memoizedState=r,t.baseState=o,t.baseQueue=s,n.lastRenderedState=r}if(e=n.interleaved,e!==null){l=e;do i=l.lane,Q.lanes|=i,It|=i,l=l.next;while(l!==e)}else l===null&&(n.lanes=0);return[t.memoizedState,n.dispatch]}function Yl(e){var t=ze(),n=t.queue;if(n===null)throw Error(x(311));n.lastRenderedReducer=e;var r=n.dispatch,l=n.pending,i=t.memoizedState;if(l!==null){n.pending=null;var o=l=l.next;do i=e(i,o.action),o=o.next;while(o!==l);$e(i,t.memoizedState)||(he=!0),t.memoizedState=i,t.baseQueue===null&&(t.baseState=i),n.lastRenderedState=i}return[i,r]}function wa(){}function Sa(e,t){var n=Q,r=ze(),l=t(),i=!$e(r.memoizedState,l);if(i&&(r.memoizedState=l,he=!0),r=r.queue,_o(Ea.bind(null,n,r,e),[e]),r.getSnapshot!==t||i||ne!==null&&ne.memoizedState.tag&1){if(n.flags|=2048,bn(9,ka.bind(null,n,r,l,t),void 0,null),re===null)throw Error(x(349));Lt&30||xa(n,t,l)}return l}function xa(e,t,n){e.flags|=16384,e={getSnapshot:t,value:n},t=Q.updateQueue,t===null?(t={lastEffect:null,stores:null},Q.updateQueue=t,t.stores=[e]):(n=t.stores,n===null?t.stores=[e]:n.push(e))}function ka(e,t,n,r){t.value=n,t.getSnapshot=r,Ca(t)&&ja(e)}function Ea(e,t,n){return n(function(){Ca(t)&&ja(e)})}function Ca(e){var t=e.getSnapshot;e=e.value;try{var n=t();return!$e(e,n)}catch{return!0}}function ja(e){var t=Je(e,1);t!==null&&De(t,e,1,-1)}function zu(e){var t=Ve();return typeof e=="function"&&(e=e()),t.memoizedState=t.baseState=e,e={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:Jn,lastRenderedState:e},t.queue=e,e=e.dispatch=Ad.bind(null,Q,e),[t.memoizedState,e]}function bn(e,t,n,r){return e={tag:e,create:t,destroy:n,deps:r,next:null},t=Q.updateQueue,t===null?(t={lastEffect:null,stores:null},Q.updateQueue=t,t.lastEffect=e.next=e):(n=t.lastEffect,n===null?t.lastEffect=e.next=e:(r=n.next,n.next=e,e.next=r,t.lastEffect=e)),e}function _a(){return ze().memoizedState}function Lr(e,t,n,r){var l=Ve();Q.flags|=e,l.memoizedState=bn(1|t,n,void 0,r===void 0?null:r)}function yl(e,t,n,r){var l=ze();r=r===void 0?null:r;var i=void 0;if(J!==null){var o=J.memoizedState;if(i=o.destroy,r!==null&&Eo(r,o.deps)){l.memoizedState=bn(t,n,i,r);return}}Q.flags|=e,l.memoizedState=bn(1|t,n,i,r)}function Lu(e,t){return Lr(8390656,8,e,t)}function _o(e,t){return yl(2048,8,e,t)}function Na(e,t){return yl(4,2,e,t)}function Oa(e,t){return yl(4,4,e,t)}function Ta(e,t){if(typeof t=="function")return e=e(),t(e),function(){t(null)};if(t!=null)return e=e(),t.current=e,function(){t.current=null}}function Pa(e,t,n){return n=n!=null?n.concat([e]):null,yl(4,4,Ta.bind(null,t,e),n)}function No(){}function za(e,t){var n=ze();t=t===void 0?null:t;var r=n.memoizedState;return r!==null&&t!==null&&Eo(t,r[1])?r[0]:(n.memoizedState=[e,t],e)}function La(e,t){var n=ze();t=t===void 0?null:t;var r=n.memoizedState;return r!==null&&t!==null&&Eo(t,r[1])?r[0]:(e=e(),n.memoizedState=[e,t],e)}function Ia(e,t,n){return Lt&21?($e(n,t)||(n=As(),Q.lanes|=n,It|=n,e.baseState=!0),t):(e.baseState&&(e.baseState=!1,he=!0),e.memoizedState=n)}function Fd(e,t){var n=A;A=n!==0&&4>n?n:4,e(!0);var r=Wl.transition;Wl.transition={};try{e(!1),t()}finally{A=n,Wl.transition=r}}function Fa(){return ze().memoizedState}function Rd(e,t,n){var r=mt(e);if(n={lane:r,action:n,hasEagerState:!1,eagerState:null,next:null},Ra(e))Aa(t,n);else if(n=da(e,t,n,r),n!==null){var l=de();De(n,e,r,l),Ma(n,t,r)}}function Ad(e,t,n){var r=mt(e),l={lane:r,action:n,hasEagerState:!1,eagerState:null,next:null};if(Ra(e))Aa(t,l);else{var i=e.alternate;if(e.lanes===0&&(i===null||i.lanes===0)&&(i=t.lastRenderedReducer,i!==null))try{var o=t.lastRenderedState,u=i(o,n);if(l.hasEagerState=!0,l.eagerState=u,$e(u,o)){var s=t.interleaved;s===null?(l.next=l,go(t)):(l.next=s.next,s.next=l),t.interleaved=l;return}}catch{}finally{}n=da(e,t,l,r),n!==null&&(l=de(),De(n,e,r,l),Ma(n,t,r))}}function Ra(e){var t=e.alternate;return e===Q||t!==null&&t===Q}function Aa(e,t){Fn=el=!0;var n=e.pending;n===null?t.next=t:(t.next=n.next,n.next=t),e.pending=t}function Ma(e,t,n){if(n&4194240){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,ro(e,n)}}var tl={readContext:Pe,useCallback:ue,useContext:ue,useEffect:ue,useImperativeHandle:ue,useInsertionEffect:ue,useLayoutEffect:ue,useMemo:ue,useReducer:ue,useRef:ue,useState:ue,useDebugValue:ue,useDeferredValue:ue,useTransition:ue,useMutableSource:ue,useSyncExternalStore:ue,useId:ue,unstable_isNewReconciler:!1},Md={readContext:Pe,useCallback:function(e,t){return Ve().memoizedState=[e,t===void 0?null:t],e},useContext:Pe,useEffect:Lu,useImperativeHandle:function(e,t,n){return n=n!=null?n.concat([e]):null,Lr(4194308,4,Ta.bind(null,t,e),n)},useLayoutEffect:function(e,t){return Lr(4194308,4,e,t)},useInsertionEffect:function(e,t){return Lr(4,2,e,t)},useMemo:function(e,t){var n=Ve();return t=t===void 0?null:t,e=e(),n.memoizedState=[e,t],e},useReducer:function(e,t,n){var r=Ve();return t=n!==void 0?n(t):t,r.memoizedState=r.baseState=t,e={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:t},r.queue=e,e=e.dispatch=Rd.bind(null,Q,e),[r.memoizedState,e]},useRef:function(e){var t=Ve();return e={current:e},t.memoizedState=e},useState:zu,useDebugValue:No,useDeferredValue:function(e){return Ve().memoizedState=e},useTransition:function(){var e=zu(!1),t=e[0];return e=Fd.bind(null,e[1]),Ve().memoizedState=e,[t,e]},useMutableSource:function(){},useSyncExternalStore:function(e,t,n){var r=Q,l=Ve();if(V){if(n===void 0)throw Error(x(407));n=n()}else{if(n=t(),re===null)throw Error(x(349));Lt&30||xa(r,t,n)}l.memoizedState=n;var i={value:n,getSnapshot:t};return l.queue=i,Lu(Ea.bind(null,r,i,e),[e]),r.flags|=2048,bn(9,ka.bind(null,r,i,n,t),void 0,null),n},useId:function(){var e=Ve(),t=re.identifierPrefix;if(V){var n=Xe,r=Ye;n=(r&~(1<<32-Me(r)-1)).toString(32)+n,t=":"+t+"R"+n,n=qn++,0<n&&(t+="H"+n.toString(32)),t+=":"}else n=Id++,t=":"+t+"r"+n.toString(32)+":";return e.memoizedState=t},unstable_isNewReconciler:!1},Dd={readContext:Pe,useCallback:za,useContext:Pe,useEffect:_o,useImperativeHandle:Pa,useInsertionEffect:Na,useLayoutEffect:Oa,useMemo:La,useReducer:Kl,useRef:_a,useState:function(){return Kl(Jn)},useDebugValue:No,useDeferredValue:function(e){var t=ze();return Ia(t,J.memoizedState,e)},useTransition:function(){var e=Kl(Jn)[0],t=ze().memoizedState;return[e,t]},useMutableSource:wa,useSyncExternalStore:Sa,useId:Fa,unstable_isNewReconciler:!1},$d={readContext:Pe,useCallback:za,useContext:Pe,useEffect:_o,useImperativeHandle:Pa,useInsertionEffect:Na,useLayoutEffect:Oa,useMemo:La,useReducer:Yl,useRef:_a,useState:function(){return Yl(Jn)},useDebugValue:No,useDeferredValue:function(e){var t=ze();return J===null?t.memoizedState=e:Ia(t,J.memoizedState,e)},useTransition:function(){var e=Yl(Jn)[0],t=ze().memoizedState;return[e,t]},useMutableSource:wa,useSyncExternalStore:Sa,useId:Fa,unstable_isNewReconciler:!1};function sn(e,t){try{var n="",r=t;do n+=pf(r),r=r.return;while(r);var l=n}catch(i){l=`
-Error generating stack: `+i.message+`
-`+i.stack}return{value:e,source:t,stack:l,digest:null}}function Xl(e,t,n){return{value:e,source:null,stack:n??null,digest:t??null}}function zi(e,t){try{console.error(t.value)}catch(n){setTimeout(function(){throw n})}}var Ud=typeof WeakMap=="function"?WeakMap:Map;function Da(e,t,n){n=Ge(-1,n),n.tag=3,n.payload={element:null};var r=t.value;return n.callback=function(){rl||(rl=!0,Vi=r),zi(e,t)},n}function $a(e,t,n){n=Ge(-1,n),n.tag=3;var r=e.type.getDerivedStateFromError;if(typeof r=="function"){var l=t.value;n.payload=function(){return r(l)},n.callback=function(){zi(e,t)}}var i=e.stateNode;return i!==null&&typeof i.componentDidCatch=="function"&&(n.callback=function(){zi(e,t),typeof r!="function"&&(pt===null?pt=new Set([this]):pt.add(this));var o=t.stack;this.componentDidCatch(t.value,{componentStack:o!==null?o:""})}),n}function Iu(e,t,n){var r=e.pingCache;if(r===null){r=e.pingCache=new Ud;var l=new Set;r.set(t,l)}else l=r.get(t),l===void 0&&(l=new Set,r.set(t,l));l.has(n)||(l.add(n),e=ep.bind(null,e,t,n),t.then(e,e))}function Fu(e){do{var t;if((t=e.tag===13)&&(t=e.memoizedState,t=t!==null?t.dehydrated!==null:!0),t)return e;e=e.return}while(e!==null);return null}function Ru(e,t,n,r,l){return e.mode&1?(e.flags|=65536,e.lanes=l,e):(e===t?e.flags|=65536:(e.flags|=128,n.flags|=131072,n.flags&=-52805,n.tag===1&&(n.alternate===null?n.tag=17:(t=Ge(-1,1),t.tag=2,dt(n,t,1))),n.lanes|=1),e)}var Vd=et.ReactCurrentOwner,he=!1;function fe(e,t,n,r){t.child=e===null?va(t,null,n,r):on(t,e.child,n,r)}function Au(e,t,n,r,l){n=n.render;var i=t.ref;return en(t,l),r=Co(e,t,n,r,i,l),n=jo(),e!==null&&!he?(t.updateQueue=e.updateQueue,t.flags&=-2053,e.lanes&=~l,be(e,t,l)):(V&&n&&fo(t),t.flags|=1,fe(e,t,r,l),t.child)}function Mu(e,t,n,r,l){if(e===null){var i=n.type;return typeof i=="function"&&!Ro(i)&&i.defaultProps===void 0&&n.compare===null&&n.defaultProps===void 0?(t.tag=15,t.type=i,Ua(e,t,i,r,l)):(e=Ar(n.type,null,r,t,t.mode,l),e.ref=t.ref,e.return=t,t.child=e)}if(i=e.child,!(e.lanes&l)){var o=i.memoizedProps;if(n=n.compare,n=n!==null?n:Wn,n(o,r)&&e.ref===t.ref)return be(e,t,l)}return t.flags|=1,e=yt(i,r),e.ref=t.ref,e.return=t,t.child=e}function Ua(e,t,n,r,l){if(e!==null){var i=e.memoizedProps;if(Wn(i,r)&&e.ref===t.ref)if(he=!1,t.pendingProps=r=i,(e.lanes&l)!==0)e.flags&131072&&(he=!0);else return t.lanes=e.lanes,be(e,t,l)}return Li(e,t,n,r,l)}function Va(e,t,n){var r=t.pendingProps,l=r.children,i=e!==null?e.memoizedState:null;if(r.mode==="hidden")if(!(t.mode&1))t.memoizedState={baseLanes:0,cachePool:null,transitions:null},D(Gt,Se),Se|=n;else{if(!(n&1073741824))return e=i!==null?i.baseLanes|n:n,t.lanes=t.childLanes=1073741824,t.memoizedState={baseLanes:e,cachePool:null,transitions:null},t.updateQueue=null,D(Gt,Se),Se|=e,null;t.memoizedState={baseLanes:0,cachePool:null,transitions:null},r=i!==null?i.baseLanes:n,D(Gt,Se),Se|=r}else i!==null?(r=i.baseLanes|n,t.memoizedState=null):r=n,D(Gt,Se),Se|=r;return fe(e,t,l,n),t.child}function Ba(e,t){var n=t.ref;(e===null&&n!==null||e!==null&&e.ref!==n)&&(t.flags|=512,t.flags|=2097152)}function Li(e,t,n,r,l){var i=ge(n)?Pt:ce.current;return i=rn(t,i),en(t,l),n=Co(e,t,n,r,i,l),r=jo(),e!==null&&!he?(t.updateQueue=e.updateQueue,t.flags&=-2053,e.lanes&=~l,be(e,t,l)):(V&&r&&fo(t),t.flags|=1,fe(e,t,n,l),t.child)}function Du(e,t,n,r,l){if(ge(n)){var i=!0;Yr(t)}else i=!1;if(en(t,l),t.stateNode===null)Ir(e,t),ya(t,n,r),Pi(t,n,r,l),r=!0;else if(e===null){var o=t.stateNode,u=t.memoizedProps;o.props=u;var s=o.context,c=n.contextType;typeof c=="object"&&c!==null?c=Pe(c):(c=ge(n)?Pt:ce.current,c=rn(t,c));var y=n.getDerivedStateFromProps,f=typeof y=="function"||typeof o.getSnapshotBeforeUpdate=="function";f||typeof o.UNSAFE_componentWillReceiveProps!="function"&&typeof o.componentWillReceiveProps!="function"||(u!==r||s!==c)&&Tu(t,o,r,c),rt=!1;var v=t.memoizedState;o.state=v,Jr(t,r,o,l),s=t.memoizedState,u!==r||v!==s||ve.current||rt?(typeof y=="function"&&(Ti(t,n,y,r),s=t.memoizedState),(u=rt||Ou(t,n,u,r,v,s,c))?(f||typeof o.UNSAFE_componentWillMount!="function"&&typeof o.componentWillMount!="function"||(typeof o.componentWillMount=="function"&&o.componentWillMount(),typeof o.UNSAFE_componentWillMount=="function"&&o.UNSAFE_componentWillMount()),typeof o.componentDidMount=="function"&&(t.flags|=4194308)):(typeof o.componentDidMount=="function"&&(t.flags|=4194308),t.memoizedProps=r,t.memoizedState=s),o.props=r,o.state=s,o.context=c,r=u):(typeof o.componentDidMount=="function"&&(t.flags|=4194308),r=!1)}else{o=t.stateNode,pa(e,t),u=t.memoizedProps,c=t.type===t.elementType?u:Fe(t.type,u),o.props=c,f=t.pendingProps,v=o.context,s=n.contextType,typeof s=="object"&&s!==null?s=Pe(s):(s=ge(n)?Pt:ce.current,s=rn(t,s));var g=n.getDerivedStateFromProps;(y=typeof g=="function"||typeof o.getSnapshotBeforeUpdate=="function")||typeof o.UNSAFE_componentWillReceiveProps!="function"&&typeof o.componentWillReceiveProps!="function"||(u!==f||v!==s)&&Tu(t,o,r,s),rt=!1,v=t.memoizedState,o.state=v,Jr(t,r,o,l);var w=t.memoizedState;u!==f||v!==w||ve.current||rt?(typeof g=="function"&&(Ti(t,n,g,r),w=t.memoizedState),(c=rt||Ou(t,n,c,r,v,w,s)||!1)?(y||typeof o.UNSAFE_componentWillUpdate!="function"&&typeof o.componentWillUpdate!="function"||(typeof o.componentWillUpdate=="function"&&o.componentWillUpdate(r,w,s),typeof o.UNSAFE_componentWillUpdate=="function"&&o.UNSAFE_componentWillUpdate(r,w,s)),typeof o.componentDidUpdate=="function"&&(t.flags|=4),typeof o.getSnapshotBeforeUpdate=="function"&&(t.flags|=1024)):(typeof o.componentDidUpdate!="function"||u===e.memoizedProps&&v===e.memoizedState||(t.flags|=4),typeof o.getSnapshotBeforeUpdate!="function"||u===e.memoizedProps&&v===e.memoizedState||(t.flags|=1024),t.memoizedProps=r,t.memoizedState=w),o.props=r,o.state=w,o.context=s,r=c):(typeof o.componentDidUpdate!="function"||u===e.memoizedProps&&v===e.memoizedState||(t.flags|=4),typeof o.getSnapshotBeforeUpdate!="function"||u===e.memoizedProps&&v===e.memoizedState||(t.flags|=1024),r=!1)}return Ii(e,t,n,r,i,l)}function Ii(e,t,n,r,l,i){Ba(e,t);var o=(t.flags&128)!==0;if(!r&&!o)return l&&Eu(t,n,!1),be(e,t,i);r=t.stateNode,Vd.current=t;var u=o&&typeof n.getDerivedStateFromError!="function"?null:r.render();return t.flags|=1,e!==null&&o?(t.child=on(t,e.child,null,i),t.child=on(t,null,u,i)):fe(e,t,u,i),t.memoizedState=r.state,l&&Eu(t,n,!0),t.child}function Qa(e){var t=e.stateNode;t.pendingContext?ku(e,t.pendingContext,t.pendingContext!==t.context):t.context&&ku(e,t.context,!1),So(e,t.containerInfo)}function $u(e,t,n,r,l){return ln(),mo(l),t.flags|=256,fe(e,t,n,r),t.child}var Fi={dehydrated:null,treeContext:null,retryLane:0};function Ri(e){return{baseLanes:e,cachePool:null,transitions:null}}function Ha(e,t,n){var r=t.pendingProps,l=B.current,i=!1,o=(t.flags&128)!==0,u;if((u=o)||(u=e!==null&&e.memoizedState===null?!1:(l&2)!==0),u?(i=!0,t.flags&=-129):(e===null||e.memoizedState!==null)&&(l|=1),D(B,l&1),e===null)return Ni(t),e=t.memoizedState,e!==null&&(e=e.dehydrated,e!==null)?(t.mode&1?e.data==="$!"?t.lanes=8:t.lanes=1073741824:t.lanes=1,null):(o=r.children,e=r.fallback,i?(r=t.mode,i=t.child,o={mode:"hidden",children:o},!(r&1)&&i!==null?(i.childLanes=0,i.pendingProps=o):i=gl(o,r,0,null),e=Tt(e,r,n,null),i.return=t,e.return=t,i.sibling=e,t.child=i,t.child.memoizedState=Ri(n),t.memoizedState=Fi,e):Oo(t,o));if(l=e.memoizedState,l!==null&&(u=l.dehydrated,u!==null))return Bd(e,t,o,r,u,l,n);if(i){i=r.fallback,o=t.mode,l=e.child,u=l.sibling;var s={mode:"hidden",children:r.children};return!(o&1)&&t.child!==l?(r=t.child,r.childLanes=0,r.pendingProps=s,t.deletions=null):(r=yt(l,s),r.subtreeFlags=l.subtreeFlags&14680064),u!==null?i=yt(u,i):(i=Tt(i,o,n,null),i.flags|=2),i.return=t,r.return=t,r.sibling=i,t.child=r,r=i,i=t.child,o=e.child.memoizedState,o=o===null?Ri(n):{baseLanes:o.baseLanes|n,cachePool:null,transitions:o.transitions},i.memoizedState=o,i.childLanes=e.childLanes&~n,t.memoizedState=Fi,r}return i=e.child,e=i.sibling,r=yt(i,{mode:"visible",children:r.children}),!(t.mode&1)&&(r.lanes=n),r.return=t,r.sibling=null,e!==null&&(n=t.deletions,n===null?(t.deletions=[e],t.flags|=16):n.push(e)),t.child=r,t.memoizedState=null,r}function Oo(e,t){return t=gl({mode:"visible",children:t},e.mode,0,null),t.return=e,e.child=t}function xr(e,t,n,r){return r!==null&&mo(r),on(t,e.child,null,n),e=Oo(t,t.pendingProps.children),e.flags|=2,t.memoizedState=null,e}function Bd(e,t,n,r,l,i,o){if(n)return t.flags&256?(t.flags&=-257,r=Xl(Error(x(422))),xr(e,t,o,r)):t.memoizedState!==null?(t.child=e.child,t.flags|=128,null):(i=r.fallback,l=t.mode,r=gl({mode:"visible",children:r.children},l,0,null),i=Tt(i,l,o,null),i.flags|=2,r.return=t,i.return=t,r.sibling=i,t.child=r,t.mode&1&&on(t,e.child,null,o),t.child.memoizedState=Ri(o),t.memoizedState=Fi,i);if(!(t.mode&1))return xr(e,t,o,null);if(l.data==="$!"){if(r=l.nextSibling&&l.nextSibling.dataset,r)var u=r.dgst;return r=u,i=Error(x(419)),r=Xl(i,r,void 0),xr(e,t,o,r)}if(u=(o&e.childLanes)!==0,he||u){if(r=re,r!==null){switch(o&-o){case 4:l=2;break;case 16:l=8;break;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:l=32;break;case 536870912:l=268435456;break;default:l=0}l=l&(r.suspendedLanes|o)?0:l,l!==0&&l!==i.retryLane&&(i.retryLane=l,Je(e,l),De(r,e,l,-1))}return Fo(),r=Xl(Error(x(421))),xr(e,t,o,r)}return l.data==="$?"?(t.flags|=128,t.child=e.child,t=tp.bind(null,e),l._reactRetry=t,null):(e=i.treeContext,xe=ft(l.nextSibling),ke=t,V=!0,Ae=null,e!==null&&(_e[Ne++]=Ye,_e[Ne++]=Xe,_e[Ne++]=zt,Ye=e.id,Xe=e.overflow,zt=t),t=Oo(t,r.children),t.flags|=4096,t)}function Uu(e,t,n){e.lanes|=t;var r=e.alternate;r!==null&&(r.lanes|=t),Oi(e.return,t,n)}function Gl(e,t,n,r,l){var i=e.memoizedState;i===null?e.memoizedState={isBackwards:t,rendering:null,renderingStartTime:0,last:r,tail:n,tailMode:l}:(i.isBackwards=t,i.rendering=null,i.renderingStartTime=0,i.last=r,i.tail=n,i.tailMode=l)}function Wa(e,t,n){var r=t.pendingProps,l=r.revealOrder,i=r.tail;if(fe(e,t,r.children,n),r=B.current,r&2)r=r&1|2,t.flags|=128;else{if(e!==null&&e.flags&128)e:for(e=t.child;e!==null;){if(e.tag===13)e.memoizedState!==null&&Uu(e,n,t);else if(e.tag===19)Uu(e,n,t);else if(e.child!==null){e.child.return=e,e=e.child;continue}if(e===t)break e;for(;e.sibling===null;){if(e.return===null||e.return===t)break e;e=e.return}e.sibling.return=e.return,e=e.sibling}r&=1}if(D(B,r),!(t.mode&1))t.memoizedState=null;else switch(l){case"forwards":for(n=t.child,l=null;n!==null;)e=n.alternate,e!==null&&br(e)===null&&(l=n),n=n.sibling;n=l,n===null?(l=t.child,t.child=null):(l=n.sibling,n.sibling=null),Gl(t,!1,l,n,i);break;case"backwards":for(n=null,l=t.child,t.child=null;l!==null;){if(e=l.alternate,e!==null&&br(e)===null){t.child=l;break}e=l.sibling,l.sibling=n,n=l,l=e}Gl(t,!0,n,null,i);break;case"together":Gl(t,!1,null,null,void 0);break;default:t.memoizedState=null}return t.child}function Ir(e,t){!(t.mode&1)&&e!==null&&(e.alternate=null,t.alternate=null,t.flags|=2)}function be(e,t,n){if(e!==null&&(t.dependencies=e.dependencies),It|=t.lanes,!(n&t.childLanes))return null;if(e!==null&&t.child!==e.child)throw Error(x(153));if(t.child!==null){for(e=t.child,n=yt(e,e.pendingProps),t.child=n,n.return=t;e.sibling!==null;)e=e.sibling,n=n.sibling=yt(e,e.pendingProps),n.return=t;n.sibling=null}return t.child}function Qd(e,t,n){switch(t.tag){case 3:Qa(t),ln();break;case 5:ga(t);break;case 1:ge(t.type)&&Yr(t);break;case 4:So(t,t.stateNode.containerInfo);break;case 10:var r=t.type._context,l=t.memoizedProps.value;D(Zr,r._currentValue),r._currentValue=l;break;case 13:if(r=t.memoizedState,r!==null)return r.dehydrated!==null?(D(B,B.current&1),t.flags|=128,null):n&t.child.childLanes?Ha(e,t,n):(D(B,B.current&1),e=be(e,t,n),e!==null?e.sibling:null);D(B,B.current&1);break;case 19:if(r=(n&t.childLanes)!==0,e.flags&128){if(r)return Wa(e,t,n);t.flags|=128}if(l=t.memoizedState,l!==null&&(l.rendering=null,l.tail=null,l.lastEffect=null),D(B,B.current),r)break;return null;case 22:case 23:return t.lanes=0,Va(e,t,n)}return be(e,t,n)}var Ka,Ai,Ya,Xa;Ka=function(e,t){for(var n=t.child;n!==null;){if(n.tag===5||n.tag===6)e.appendChild(n.stateNode);else if(n.tag!==4&&n.child!==null){n.child.return=n,n=n.child;continue}if(n===t)break;for(;n.sibling===null;){if(n.return===null||n.return===t)return;n=n.return}n.sibling.return=n.return,n=n.sibling}};Ai=function(){};Ya=function(e,t,n,r){var l=e.memoizedProps;if(l!==r){e=t.stateNode,Nt(He.current);var i=null;switch(n){case"input":l=li(e,l),r=li(e,r),i=[];break;case"select":l=H({},l,{value:void 0}),r=H({},r,{value:void 0}),i=[];break;case"textarea":l=ui(e,l),r=ui(e,r),i=[];break;default:typeof l.onClick!="function"&&typeof r.onClick=="function"&&(e.onclick=Wr)}ai(n,r);var o;n=null;for(c in l)if(!r.hasOwnProperty(c)&&l.hasOwnProperty(c)&&l[c]!=null)if(c==="style"){var u=l[c];for(o in u)u.hasOwnProperty(o)&&(n||(n={}),n[o]="")}else c!=="dangerouslySetInnerHTML"&&c!=="children"&&c!=="suppressContentEditableWarning"&&c!=="suppressHydrationWarning"&&c!=="autoFocus"&&(Dn.hasOwnProperty(c)?i||(i=[]):(i=i||[]).push(c,null));for(c in r){var s=r[c];if(u=l!=null?l[c]:void 0,r.hasOwnProperty(c)&&s!==u&&(s!=null||u!=null))if(c==="style")if(u){for(o in u)!u.hasOwnProperty(o)||s&&s.hasOwnProperty(o)||(n||(n={}),n[o]="");for(o in s)s.hasOwnProperty(o)&&u[o]!==s[o]&&(n||(n={}),n[o]=s[o])}else n||(i||(i=[]),i.push(c,n)),n=s;else c==="dangerouslySetInnerHTML"?(s=s?s.__html:void 0,u=u?u.__html:void 0,s!=null&&u!==s&&(i=i||[]).push(c,s)):c==="children"?typeof s!="string"&&typeof s!="number"||(i=i||[]).push(c,""+s):c!=="suppressContentEditableWarning"&&c!=="suppressHydrationWarning"&&(Dn.hasOwnProperty(c)?(s!=null&&c==="onScroll"&&$("scroll",e),i||u===s||(i=[])):(i=i||[]).push(c,s))}n&&(i=i||[]).push("style",n);var c=i;(t.updateQueue=c)&&(t.flags|=4)}};Xa=function(e,t,n,r){n!==r&&(t.flags|=4)};function En(e,t){if(!V)switch(e.tailMode){case"hidden":t=e.tail;for(var n=null;t!==null;)t.alternate!==null&&(n=t),t=t.sibling;n===null?e.tail=null:n.sibling=null;break;case"collapsed":n=e.tail;for(var r=null;n!==null;)n.alternate!==null&&(r=n),n=n.sibling;r===null?t||e.tail===null?e.tail=null:e.tail.sibling=null:r.sibling=null}}function se(e){var t=e.alternate!==null&&e.alternate.child===e.child,n=0,r=0;if(t)for(var l=e.child;l!==null;)n|=l.lanes|l.childLanes,r|=l.subtreeFlags&14680064,r|=l.flags&14680064,l.return=e,l=l.sibling;else for(l=e.child;l!==null;)n|=l.lanes|l.childLanes,r|=l.subtreeFlags,r|=l.flags,l.return=e,l=l.sibling;return e.subtreeFlags|=r,e.childLanes=n,t}function Hd(e,t,n){var r=t.pendingProps;switch(po(t),t.tag){case 2:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return se(t),null;case 1:return ge(t.type)&&Kr(),se(t),null;case 3:return r=t.stateNode,un(),U(ve),U(ce),ko(),r.pendingContext&&(r.context=r.pendingContext,r.pendingContext=null),(e===null||e.child===null)&&(wr(t)?t.flags|=4:e===null||e.memoizedState.isDehydrated&&!(t.flags&256)||(t.flags|=1024,Ae!==null&&(Hi(Ae),Ae=null))),Ai(e,t),se(t),null;case 5:xo(t);var l=Nt(Zn.current);if(n=t.type,e!==null&&t.stateNode!=null)Ya(e,t,n,r,l),e.ref!==t.ref&&(t.flags|=512,t.flags|=2097152);else{if(!r){if(t.stateNode===null)throw Error(x(166));return se(t),null}if(e=Nt(He.current),wr(t)){r=t.stateNode,n=t.type;var i=t.memoizedProps;switch(r[Be]=t,r[Xn]=i,e=(t.mode&1)!==0,n){case"dialog":$("cancel",r),$("close",r);break;case"iframe":case"object":case"embed":$("load",r);break;case"video":case"audio":for(l=0;l<On.length;l++)$(On[l],r);break;case"source":$("error",r);break;case"img":case"image":case"link":$("error",r),$("load",r);break;case"details":$("toggle",r);break;case"input":Go(r,i),$("invalid",r);break;case"select":r._wrapperState={wasMultiple:!!i.multiple},$("invalid",r);break;case"textarea":qo(r,i),$("invalid",r)}ai(n,i),l=null;for(var o in i)if(i.hasOwnProperty(o)){var u=i[o];o==="children"?typeof u=="string"?r.textContent!==u&&(i.suppressHydrationWarning!==!0&&gr(r.textContent,u,e),l=["children",u]):typeof u=="number"&&r.textContent!==""+u&&(i.suppressHydrationWarning!==!0&&gr(r.textContent,u,e),l=["children",""+u]):Dn.hasOwnProperty(o)&&u!=null&&o==="onScroll"&&$("scroll",r)}switch(n){case"input":cr(r),Zo(r,i,!0);break;case"textarea":cr(r),Jo(r);break;case"select":case"option":break;default:typeof i.onClick=="function"&&(r.onclick=Wr)}r=l,t.updateQueue=r,r!==null&&(t.flags|=4)}else{o=l.nodeType===9?l:l.ownerDocument,e==="http://www.w3.org/1999/xhtml"&&(e=xs(n)),e==="http://www.w3.org/1999/xhtml"?n==="script"?(e=o.createElement("div"),e.innerHTML="<script><\/script>",e=e.removeChild(e.firstChild)):typeof r.is=="string"?e=o.createElement(n,{is:r.is}):(e=o.createElement(n),n==="select"&&(o=e,r.multiple?o.multiple=!0:r.size&&(o.size=r.size))):e=o.createElementNS(e,n),e[Be]=t,e[Xn]=r,Ka(e,t,!1,!1),t.stateNode=e;e:{switch(o=ci(n,r),n){case"dialog":$("cancel",e),$("close",e),l=r;break;case"iframe":case"object":case"embed":$("load",e),l=r;break;case"video":case"audio":for(l=0;l<On.length;l++)$(On[l],e);l=r;break;case"source":$("error",e),l=r;break;case"img":case"image":case"link":$("error",e),$("load",e),l=r;break;case"details":$("toggle",e),l=r;break;case"input":Go(e,r),l=li(e,r),$("invalid",e);break;case"option":l=r;break;case"select":e._wrapperState={wasMultiple:!!r.multiple},l=H({},r,{value:void 0}),$("invalid",e);break;case"textarea":qo(e,r),l=ui(e,r),$("invalid",e);break;default:l=r}ai(n,l),u=l;for(i in u)if(u.hasOwnProperty(i)){var s=u[i];i==="style"?Cs(e,s):i==="dangerouslySetInnerHTML"?(s=s?s.__html:void 0,s!=null&&ks(e,s)):i==="children"?typeof s=="string"?(n!=="textarea"||s!=="")&&$n(e,s):typeof s=="number"&&$n(e,""+s):i!=="suppressContentEditableWarning"&&i!=="suppressHydrationWarning"&&i!=="autoFocus"&&(Dn.hasOwnProperty(i)?s!=null&&i==="onScroll"&&$("scroll",e):s!=null&&qi(e,i,s,o))}switch(n){case"input":cr(e),Zo(e,r,!1);break;case"textarea":cr(e),Jo(e);break;case"option":r.value!=null&&e.setAttribute("value",""+ht(r.value));break;case"select":e.multiple=!!r.multiple,i=r.value,i!=null?Zt(e,!!r.multiple,i,!1):r.defaultValue!=null&&Zt(e,!!r.multiple,r.defaultValue,!0);break;default:typeof l.onClick=="function"&&(e.onclick=Wr)}switch(n){case"button":case"input":case"select":case"textarea":r=!!r.autoFocus;break e;case"img":r=!0;break e;default:r=!1}}r&&(t.flags|=4)}t.ref!==null&&(t.flags|=512,t.flags|=2097152)}return se(t),null;case 6:if(e&&t.stateNode!=null)Xa(e,t,e.memoizedProps,r);else{if(typeof r!="string"&&t.stateNode===null)throw Error(x(166));if(n=Nt(Zn.current),Nt(He.current),wr(t)){if(r=t.stateNode,n=t.memoizedProps,r[Be]=t,(i=r.nodeValue!==n)&&(e=ke,e!==null))switch(e.tag){case 3:gr(r.nodeValue,n,(e.mode&1)!==0);break;case 5:e.memoizedProps.suppressHydrationWarning!==!0&&gr(r.nodeValue,n,(e.mode&1)!==0)}i&&(t.flags|=4)}else r=(n.nodeType===9?n:n.ownerDocument).createTextNode(r),r[Be]=t,t.stateNode=r}return se(t),null;case 13:if(U(B),r=t.memoizedState,e===null||e.memoizedState!==null&&e.memoizedState.dehydrated!==null){if(V&&xe!==null&&t.mode&1&&!(t.flags&128))fa(),ln(),t.flags|=98560,i=!1;else if(i=wr(t),r!==null&&r.dehydrated!==null){if(e===null){if(!i)throw Error(x(318));if(i=t.memoizedState,i=i!==null?i.dehydrated:null,!i)throw Error(x(317));i[Be]=t}else ln(),!(t.flags&128)&&(t.memoizedState=null),t.flags|=4;se(t),i=!1}else Ae!==null&&(Hi(Ae),Ae=null),i=!0;if(!i)return t.flags&65536?t:null}return t.flags&128?(t.lanes=n,t):(r=r!==null,r!==(e!==null&&e.memoizedState!==null)&&r&&(t.child.flags|=8192,t.mode&1&&(e===null||B.current&1?b===0&&(b=3):Fo())),t.updateQueue!==null&&(t.flags|=4),se(t),null);case 4:return un(),Ai(e,t),e===null&&Kn(t.stateNode.containerInfo),se(t),null;case 10:return vo(t.type._context),se(t),null;case 17:return ge(t.type)&&Kr(),se(t),null;case 19:if(U(B),i=t.memoizedState,i===null)return se(t),null;if(r=(t.flags&128)!==0,o=i.rendering,o===null)if(r)En(i,!1);else{if(b!==0||e!==null&&e.flags&128)for(e=t.child;e!==null;){if(o=br(e),o!==null){for(t.flags|=128,En(i,!1),r=o.updateQueue,r!==null&&(t.updateQueue=r,t.flags|=4),t.subtreeFlags=0,r=n,n=t.child;n!==null;)i=n,e=r,i.flags&=14680066,o=i.alternate,o===null?(i.childLanes=0,i.lanes=e,i.child=null,i.subtreeFlags=0,i.memoizedProps=null,i.memoizedState=null,i.updateQueue=null,i.dependencies=null,i.stateNode=null):(i.childLanes=o.childLanes,i.lanes=o.lanes,i.child=o.child,i.subtreeFlags=0,i.deletions=null,i.memoizedProps=o.memoizedProps,i.memoizedState=o.memoizedState,i.updateQueue=o.updateQueue,i.type=o.type,e=o.dependencies,i.dependencies=e===null?null:{lanes:e.lanes,firstContext:e.firstContext}),n=n.sibling;return D(B,B.current&1|2),t.child}e=e.sibling}i.tail!==null&&G()>an&&(t.flags|=128,r=!0,En(i,!1),t.lanes=4194304)}else{if(!r)if(e=br(o),e!==null){if(t.flags|=128,r=!0,n=e.updateQueue,n!==null&&(t.updateQueue=n,t.flags|=4),En(i,!0),i.tail===null&&i.tailMode==="hidden"&&!o.alternate&&!V)return se(t),null}else 2*G()-i.renderingStartTime>an&&n!==1073741824&&(t.flags|=128,r=!0,En(i,!1),t.lanes=4194304);i.isBackwards?(o.sibling=t.child,t.child=o):(n=i.last,n!==null?n.sibling=o:t.child=o,i.last=o)}return i.tail!==null?(t=i.tail,i.rendering=t,i.tail=t.sibling,i.renderingStartTime=G(),t.sibling=null,n=B.current,D(B,r?n&1|2:n&1),t):(se(t),null);case 22:case 23:return Io(),r=t.memoizedState!==null,e!==null&&e.memoizedState!==null!==r&&(t.flags|=8192),r&&t.mode&1?Se&1073741824&&(se(t),t.subtreeFlags&6&&(t.flags|=8192)):se(t),null;case 24:return null;case 25:return null}throw Error(x(156,t.tag))}function Wd(e,t){switch(po(t),t.tag){case 1:return ge(t.type)&&Kr(),e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 3:return un(),U(ve),U(ce),ko(),e=t.flags,e&65536&&!(e&128)?(t.flags=e&-65537|128,t):null;case 5:return xo(t),null;case 13:if(U(B),e=t.memoizedState,e!==null&&e.dehydrated!==null){if(t.alternate===null)throw Error(x(340));ln()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 19:return U(B),null;case 4:return un(),null;case 10:return vo(t.type._context),null;case 22:case 23:return Io(),null;case 24:return null;default:return null}}var kr=!1,ae=!1,Kd=typeof WeakSet=="function"?WeakSet:Set,E=null;function Xt(e,t){var n=e.ref;if(n!==null)if(typeof n=="function")try{n(null)}catch(r){K(e,t,r)}else n.current=null}function Mi(e,t,n){try{n()}catch(r){K(e,t,r)}}var Vu=!1;function Yd(e,t){if(Si=Br,e=Js(),co(e)){if("selectionStart"in e)var n={start:e.selectionStart,end:e.selectionEnd};else e:{n=(n=e.ownerDocument)&&n.defaultView||window;var r=n.getSelection&&n.getSelection();if(r&&r.rangeCount!==0){n=r.anchorNode;var l=r.anchorOffset,i=r.focusNode;r=r.focusOffset;try{n.nodeType,i.nodeType}catch{n=null;break e}var o=0,u=-1,s=-1,c=0,y=0,f=e,v=null;t:for(;;){for(var g;f!==n||l!==0&&f.nodeType!==3||(u=o+l),f!==i||r!==0&&f.nodeType!==3||(s=o+r),f.nodeType===3&&(o+=f.nodeValue.length),(g=f.firstChild)!==null;)v=f,f=g;for(;;){if(f===e)break t;if(v===n&&++c===l&&(u=o),v===i&&++y===r&&(s=o),(g=f.nextSibling)!==null)break;f=v,v=f.parentNode}f=g}n=u===-1||s===-1?null:{start:u,end:s}}else n=null}n=n||{start:0,end:0}}else n=null;for(xi={focusedElem:e,selectionRange:n},Br=!1,E=t;E!==null;)if(t=E,e=t.child,(t.subtreeFlags&1028)!==0&&e!==null)e.return=t,E=e;else for(;E!==null;){t=E;try{var w=t.alternate;if(t.flags&1024)switch(t.tag){case 0:case 11:case 15:break;case 1:if(w!==null){var k=w.memoizedProps,M=w.memoizedState,p=t.stateNode,d=p.getSnapshotBeforeUpdate(t.elementType===t.type?k:Fe(t.type,k),M);p.__reactInternalSnapshotBeforeUpdate=d}break;case 3:var h=t.stateNode.containerInfo;h.nodeType===1?h.textContent="":h.nodeType===9&&h.documentElement&&h.removeChild(h.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(x(163))}}catch(S){K(t,t.return,S)}if(e=t.sibling,e!==null){e.return=t.return,E=e;break}E=t.return}return w=Vu,Vu=!1,w}function Rn(e,t,n){var r=t.updateQueue;if(r=r!==null?r.lastEffect:null,r!==null){var l=r=r.next;do{if((l.tag&e)===e){var i=l.destroy;l.destroy=void 0,i!==void 0&&Mi(t,n,i)}l=l.next}while(l!==r)}}function hl(e,t){if(t=t.updateQueue,t=t!==null?t.lastEffect:null,t!==null){var n=t=t.next;do{if((n.tag&e)===e){var r=n.create;n.destroy=r()}n=n.next}while(n!==t)}}function Di(e){var t=e.ref;if(t!==null){var n=e.stateNode;switch(e.tag){case 5:e=n;break;default:e=n}typeof t=="function"?t(e):t.current=e}}function Ga(e){var t=e.alternate;t!==null&&(e.alternate=null,Ga(t)),e.child=null,e.deletions=null,e.sibling=null,e.tag===5&&(t=e.stateNode,t!==null&&(delete t[Be],delete t[Xn],delete t[Ci],delete t[Td],delete t[Pd])),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}function Za(e){return e.tag===5||e.tag===3||e.tag===4}function Bu(e){e:for(;;){for(;e.sibling===null;){if(e.return===null||Za(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;e.tag!==5&&e.tag!==6&&e.tag!==18;){if(e.flags&2||e.child===null||e.tag===4)continue e;e.child.return=e,e=e.child}if(!(e.flags&2))return e.stateNode}}function $i(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?n.nodeType===8?n.parentNode.insertBefore(e,t):n.insertBefore(e,t):(n.nodeType===8?(t=n.parentNode,t.insertBefore(e,n)):(t=n,t.appendChild(e)),n=n._reactRootContainer,n!=null||t.onclick!==null||(t.onclick=Wr));else if(r!==4&&(e=e.child,e!==null))for($i(e,t,n),e=e.sibling;e!==null;)$i(e,t,n),e=e.sibling}function Ui(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?n.insertBefore(e,t):n.appendChild(e);else if(r!==4&&(e=e.child,e!==null))for(Ui(e,t,n),e=e.sibling;e!==null;)Ui(e,t,n),e=e.sibling}var le=null,Re=!1;function tt(e,t,n){for(n=n.child;n!==null;)qa(e,t,n),n=n.sibling}function qa(e,t,n){if(Qe&&typeof Qe.onCommitFiberUnmount=="function")try{Qe.onCommitFiberUnmount(sl,n)}catch{}switch(n.tag){case 5:ae||Xt(n,t);case 6:var r=le,l=Re;le=null,tt(e,t,n),le=r,Re=l,le!==null&&(Re?(e=le,n=n.stateNode,e.nodeType===8?e.parentNode.removeChild(n):e.removeChild(n)):le.removeChild(n.stateNode));break;case 18:le!==null&&(Re?(e=le,n=n.stateNode,e.nodeType===8?Bl(e.parentNode,n):e.nodeType===1&&Bl(e,n),Qn(e)):Bl(le,n.stateNode));break;case 4:r=le,l=Re,le=n.stateNode.containerInfo,Re=!0,tt(e,t,n),le=r,Re=l;break;case 0:case 11:case 14:case 15:if(!ae&&(r=n.updateQueue,r!==null&&(r=r.lastEffect,r!==null))){l=r=r.next;do{var i=l,o=i.destroy;i=i.tag,o!==void 0&&(i&2||i&4)&&Mi(n,t,o),l=l.next}while(l!==r)}tt(e,t,n);break;case 1:if(!ae&&(Xt(n,t),r=n.stateNode,typeof r.componentWillUnmount=="function"))try{r.props=n.memoizedProps,r.state=n.memoizedState,r.componentWillUnmount()}catch(u){K(n,t,u)}tt(e,t,n);break;case 21:tt(e,t,n);break;case 22:n.mode&1?(ae=(r=ae)||n.memoizedState!==null,tt(e,t,n),ae=r):tt(e,t,n);break;default:tt(e,t,n)}}function Qu(e){var t=e.updateQueue;if(t!==null){e.updateQueue=null;var n=e.stateNode;n===null&&(n=e.stateNode=new Kd),t.forEach(function(r){var l=np.bind(null,e,r);n.has(r)||(n.add(r),r.then(l,l))})}}function Ie(e,t){var n=t.deletions;if(n!==null)for(var r=0;r<n.length;r++){var l=n[r];try{var i=e,o=t,u=o;e:for(;u!==null;){switch(u.tag){case 5:le=u.stateNode,Re=!1;break e;case 3:le=u.stateNode.containerInfo,Re=!0;break e;case 4:le=u.stateNode.containerInfo,Re=!0;break e}u=u.return}if(le===null)throw Error(x(160));qa(i,o,l),le=null,Re=!1;var s=l.alternate;s!==null&&(s.return=null),l.return=null}catch(c){K(l,t,c)}}if(t.subtreeFlags&12854)for(t=t.child;t!==null;)Ja(t,e),t=t.sibling}function Ja(e,t){var n=e.alternate,r=e.flags;switch(e.tag){case 0:case 11:case 14:case 15:if(Ie(t,e),Ue(e),r&4){try{Rn(3,e,e.return),hl(3,e)}catch(k){K(e,e.return,k)}try{Rn(5,e,e.return)}catch(k){K(e,e.return,k)}}break;case 1:Ie(t,e),Ue(e),r&512&&n!==null&&Xt(n,n.return);break;case 5:if(Ie(t,e),Ue(e),r&512&&n!==null&&Xt(n,n.return),e.flags&32){var l=e.stateNode;try{$n(l,"")}catch(k){K(e,e.return,k)}}if(r&4&&(l=e.stateNode,l!=null)){var i=e.memoizedProps,o=n!==null?n.memoizedProps:i,u=e.type,s=e.updateQueue;if(e.updateQueue=null,s!==null)try{u==="input"&&i.type==="radio"&&i.name!=null&&ws(l,i),ci(u,o);var c=ci(u,i);for(o=0;o<s.length;o+=2){var y=s[o],f=s[o+1];y==="style"?Cs(l,f):y==="dangerouslySetInnerHTML"?ks(l,f):y==="children"?$n(l,f):qi(l,y,f,c)}switch(u){case"input":ii(l,i);break;case"textarea":Ss(l,i);break;case"select":var v=l._wrapperState.wasMultiple;l._wrapperState.wasMultiple=!!i.multiple;var g=i.value;g!=null?Zt(l,!!i.multiple,g,!1):v!==!!i.multiple&&(i.defaultValue!=null?Zt(l,!!i.multiple,i.defaultValue,!0):Zt(l,!!i.multiple,i.multiple?[]:"",!1))}l[Xn]=i}catch(k){K(e,e.return,k)}}break;case 6:if(Ie(t,e),Ue(e),r&4){if(e.stateNode===null)throw Error(x(162));l=e.stateNode,i=e.memoizedProps;try{l.nodeValue=i}catch(k){K(e,e.return,k)}}break;case 3:if(Ie(t,e),Ue(e),r&4&&n!==null&&n.memoizedState.isDehydrated)try{Qn(t.containerInfo)}catch(k){K(e,e.return,k)}break;case 4:Ie(t,e),Ue(e);break;case 13:Ie(t,e),Ue(e),l=e.child,l.flags&8192&&(i=l.memoizedState!==null,l.stateNode.isHidden=i,!i||l.alternate!==null&&l.alternate.memoizedState!==null||(zo=G())),r&4&&Qu(e);break;case 22:if(y=n!==null&&n.memoizedState!==null,e.mode&1?(ae=(c=ae)||y,Ie(t,e),ae=c):Ie(t,e),Ue(e),r&8192){if(c=e.memoizedState!==null,(e.stateNode.isHidden=c)&&!y&&e.mode&1)for(E=e,y=e.child;y!==null;){for(f=E=y;E!==null;){switch(v=E,g=v.child,v.tag){case 0:case 11:case 14:case 15:Rn(4,v,v.return);break;case 1:Xt(v,v.return);var w=v.stateNode;if(typeof w.componentWillUnmount=="function"){r=v,n=v.return;try{t=r,w.props=t.memoizedProps,w.state=t.memoizedState,w.componentWillUnmount()}catch(k){K(r,n,k)}}break;case 5:Xt(v,v.return);break;case 22:if(v.memoizedState!==null){Wu(f);continue}}g!==null?(g.return=v,E=g):Wu(f)}y=y.sibling}e:for(y=null,f=e;;){if(f.tag===5){if(y===null){y=f;try{l=f.stateNode,c?(i=l.style,typeof i.setProperty=="function"?i.setProperty("display","none","important"):i.display="none"):(u=f.stateNode,s=f.memoizedProps.style,o=s!=null&&s.hasOwnProperty("display")?s.display:null,u.style.display=Es("display",o))}catch(k){K(e,e.return,k)}}}else if(f.tag===6){if(y===null)try{f.stateNode.nodeValue=c?"":f.memoizedProps}catch(k){K(e,e.return,k)}}else if((f.tag!==22&&f.tag!==23||f.memoizedState===null||f===e)&&f.child!==null){f.child.return=f,f=f.child;continue}if(f===e)break e;for(;f.sibling===null;){if(f.return===null||f.return===e)break e;y===f&&(y=null),f=f.return}y===f&&(y=null),f.sibling.return=f.return,f=f.sibling}}break;case 19:Ie(t,e),Ue(e),r&4&&Qu(e);break;case 21:break;default:Ie(t,e),Ue(e)}}function Ue(e){var t=e.flags;if(t&2){try{e:{for(var n=e.return;n!==null;){if(Za(n)){var r=n;break e}n=n.return}throw Error(x(160))}switch(r.tag){case 5:var l=r.stateNode;r.flags&32&&($n(l,""),r.flags&=-33);var i=Bu(e);Ui(e,i,l);break;case 3:case 4:var o=r.stateNode.containerInfo,u=Bu(e);$i(e,u,o);break;default:throw Error(x(161))}}catch(s){K(e,e.return,s)}e.flags&=-3}t&4096&&(e.flags&=-4097)}function Xd(e,t,n){E=e,ba(e)}function ba(e,t,n){for(var r=(e.mode&1)!==0;E!==null;){var l=E,i=l.child;if(l.tag===22&&r){var o=l.memoizedState!==null||kr;if(!o){var u=l.alternate,s=u!==null&&u.memoizedState!==null||ae;u=kr;var c=ae;if(kr=o,(ae=s)&&!c)for(E=l;E!==null;)o=E,s=o.child,o.tag===22&&o.memoizedState!==null?Ku(l):s!==null?(s.return=o,E=s):Ku(l);for(;i!==null;)E=i,ba(i),i=i.sibling;E=l,kr=u,ae=c}Hu(e)}else l.subtreeFlags&8772&&i!==null?(i.return=l,E=i):Hu(e)}}function Hu(e){for(;E!==null;){var t=E;if(t.flags&8772){var n=t.alternate;try{if(t.flags&8772)switch(t.tag){case 0:case 11:case 15:ae||hl(5,t);break;case 1:var r=t.stateNode;if(t.flags&4&&!ae)if(n===null)r.componentDidMount();else{var l=t.elementType===t.type?n.memoizedProps:Fe(t.type,n.memoizedProps);r.componentDidUpdate(l,n.memoizedState,r.__reactInternalSnapshotBeforeUpdate)}var i=t.updateQueue;i!==null&&Nu(t,i,r);break;case 3:var o=t.updateQueue;if(o!==null){if(n=null,t.child!==null)switch(t.child.tag){case 5:n=t.child.stateNode;break;case 1:n=t.child.stateNode}Nu(t,o,n)}break;case 5:var u=t.stateNode;if(n===null&&t.flags&4){n=u;var s=t.memoizedProps;switch(t.type){case"button":case"input":case"select":case"textarea":s.autoFocus&&n.focus();break;case"img":s.src&&(n.src=s.src)}}break;case 6:break;case 4:break;case 12:break;case 13:if(t.memoizedState===null){var c=t.alternate;if(c!==null){var y=c.memoizedState;if(y!==null){var f=y.dehydrated;f!==null&&Qn(f)}}}break;case 19:case 17:case 21:case 22:case 23:case 25:break;default:throw Error(x(163))}ae||t.flags&512&&Di(t)}catch(v){K(t,t.return,v)}}if(t===e){E=null;break}if(n=t.sibling,n!==null){n.return=t.return,E=n;break}E=t.return}}function Wu(e){for(;E!==null;){var t=E;if(t===e){E=null;break}var n=t.sibling;if(n!==null){n.return=t.return,E=n;break}E=t.return}}function Ku(e){for(;E!==null;){var t=E;try{switch(t.tag){case 0:case 11:case 15:var n=t.return;try{hl(4,t)}catch(s){K(t,n,s)}break;case 1:var r=t.stateNode;if(typeof r.componentDidMount=="function"){var l=t.return;try{r.componentDidMount()}catch(s){K(t,l,s)}}var i=t.return;try{Di(t)}catch(s){K(t,i,s)}break;case 5:var o=t.return;try{Di(t)}catch(s){K(t,o,s)}}}catch(s){K(t,t.return,s)}if(t===e){E=null;break}var u=t.sibling;if(u!==null){u.return=t.return,E=u;break}E=t.return}}var Gd=Math.ceil,nl=et.ReactCurrentDispatcher,To=et.ReactCurrentOwner,Te=et.ReactCurrentBatchConfig,R=0,re=null,q=null,ie=0,Se=0,Gt=wt(0),b=0,er=null,It=0,vl=0,Po=0,An=null,ye=null,zo=0,an=1/0,We=null,rl=!1,Vi=null,pt=null,Er=!1,ut=null,ll=0,Mn=0,Bi=null,Fr=-1,Rr=0;function de(){return R&6?G():Fr!==-1?Fr:Fr=G()}function mt(e){return e.mode&1?R&2&&ie!==0?ie&-ie:Ld.transition!==null?(Rr===0&&(Rr=As()),Rr):(e=A,e!==0||(e=window.event,e=e===void 0?16:Qs(e.type)),e):1}function De(e,t,n,r){if(50<Mn)throw Mn=0,Bi=null,Error(x(185));nr(e,n,r),(!(R&2)||e!==re)&&(e===re&&(!(R&2)&&(vl|=n),b===4&&it(e,ie)),we(e,r),n===1&&R===0&&!(t.mode&1)&&(an=G()+500,pl&&St()))}function we(e,t){var n=e.callbackNode;Lf(e,t);var r=Vr(e,e===re?ie:0);if(r===0)n!==null&&tu(n),e.callbackNode=null,e.callbackPriority=0;else if(t=r&-r,e.callbackPriority!==t){if(n!=null&&tu(n),t===1)e.tag===0?zd(Yu.bind(null,e)):sa(Yu.bind(null,e)),Nd(function(){!(R&6)&&St()}),n=null;else{switch(Ms(r)){case 1:n=no;break;case 4:n=Fs;break;case 16:n=Ur;break;case 536870912:n=Rs;break;default:n=Ur}n=uc(n,ec.bind(null,e))}e.callbackPriority=t,e.callbackNode=n}}function ec(e,t){if(Fr=-1,Rr=0,R&6)throw Error(x(327));var n=e.callbackNode;if(tn()&&e.callbackNode!==n)return null;var r=Vr(e,e===re?ie:0);if(r===0)return null;if(r&30||r&e.expiredLanes||t)t=il(e,r);else{t=r;var l=R;R|=2;var i=nc();(re!==e||ie!==t)&&(We=null,an=G()+500,Ot(e,t));do try{Jd();break}catch(u){tc(e,u)}while(1);ho(),nl.current=i,R=l,q!==null?t=0:(re=null,ie=0,t=b)}if(t!==0){if(t===2&&(l=yi(e),l!==0&&(r=l,t=Qi(e,l))),t===1)throw n=er,Ot(e,0),it(e,r),we(e,G()),n;if(t===6)it(e,r);else{if(l=e.current.alternate,!(r&30)&&!Zd(l)&&(t=il(e,r),t===2&&(i=yi(e),i!==0&&(r=i,t=Qi(e,i))),t===1))throw n=er,Ot(e,0),it(e,r),we(e,G()),n;switch(e.finishedWork=l,e.finishedLanes=r,t){case 0:case 1:throw Error(x(345));case 2:Ct(e,ye,We);break;case 3:if(it(e,r),(r&130023424)===r&&(t=zo+500-G(),10<t)){if(Vr(e,0)!==0)break;if(l=e.suspendedLanes,(l&r)!==r){de(),e.pingedLanes|=e.suspendedLanes&l;break}e.timeoutHandle=Ei(Ct.bind(null,e,ye,We),t);break}Ct(e,ye,We);break;case 4:if(it(e,r),(r&4194240)===r)break;for(t=e.eventTimes,l=-1;0<r;){var o=31-Me(r);i=1<<o,o=t[o],o>l&&(l=o),r&=~i}if(r=l,r=G()-r,r=(120>r?120:480>r?480:1080>r?1080:1920>r?1920:3e3>r?3e3:4320>r?4320:1960*Gd(r/1960))-r,10<r){e.timeoutHandle=Ei(Ct.bind(null,e,ye,We),r);break}Ct(e,ye,We);break;case 5:Ct(e,ye,We);break;default:throw Error(x(329))}}}return we(e,G()),e.callbackNode===n?ec.bind(null,e):null}function Qi(e,t){var n=An;return e.current.memoizedState.isDehydrated&&(Ot(e,t).flags|=256),e=il(e,t),e!==2&&(t=ye,ye=n,t!==null&&Hi(t)),e}function Hi(e){ye===null?ye=e:ye.push.apply(ye,e)}function Zd(e){for(var t=e;;){if(t.flags&16384){var n=t.updateQueue;if(n!==null&&(n=n.stores,n!==null))for(var r=0;r<n.length;r++){var l=n[r],i=l.getSnapshot;l=l.value;try{if(!$e(i(),l))return!1}catch{return!1}}}if(n=t.child,t.subtreeFlags&16384&&n!==null)n.return=t,t=n;else{if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return!0;t=t.return}t.sibling.return=t.return,t=t.sibling}}return!0}function it(e,t){for(t&=~Po,t&=~vl,e.suspendedLanes|=t,e.pingedLanes&=~t,e=e.expirationTimes;0<t;){var n=31-Me(t),r=1<<n;e[n]=-1,t&=~r}}function Yu(e){if(R&6)throw Error(x(327));tn();var t=Vr(e,0);if(!(t&1))return we(e,G()),null;var n=il(e,t);if(e.tag!==0&&n===2){var r=yi(e);r!==0&&(t=r,n=Qi(e,r))}if(n===1)throw n=er,Ot(e,0),it(e,t),we(e,G()),n;if(n===6)throw Error(x(345));return e.finishedWork=e.current.alternate,e.finishedLanes=t,Ct(e,ye,We),we(e,G()),null}function Lo(e,t){var n=R;R|=1;try{return e(t)}finally{R=n,R===0&&(an=G()+500,pl&&St())}}function Ft(e){ut!==null&&ut.tag===0&&!(R&6)&&tn();var t=R;R|=1;var n=Te.transition,r=A;try{if(Te.transition=null,A=1,e)return e()}finally{A=r,Te.transition=n,R=t,!(R&6)&&St()}}function Io(){Se=Gt.current,U(Gt)}function Ot(e,t){e.finishedWork=null,e.finishedLanes=0;var n=e.timeoutHandle;if(n!==-1&&(e.timeoutHandle=-1,_d(n)),q!==null)for(n=q.return;n!==null;){var r=n;switch(po(r),r.tag){case 1:r=r.type.childContextTypes,r!=null&&Kr();break;case 3:un(),U(ve),U(ce),ko();break;case 5:xo(r);break;case 4:un();break;case 13:U(B);break;case 19:U(B);break;case 10:vo(r.type._context);break;case 22:case 23:Io()}n=n.return}if(re=e,q=e=yt(e.current,null),ie=Se=t,b=0,er=null,Po=vl=It=0,ye=An=null,_t!==null){for(t=0;t<_t.length;t++)if(n=_t[t],r=n.interleaved,r!==null){n.interleaved=null;var l=r.next,i=n.pending;if(i!==null){var o=i.next;i.next=l,r.next=o}n.pending=r}_t=null}return e}function tc(e,t){do{var n=q;try{if(ho(),zr.current=tl,el){for(var r=Q.memoizedState;r!==null;){var l=r.queue;l!==null&&(l.pending=null),r=r.next}el=!1}if(Lt=0,ne=J=Q=null,Fn=!1,qn=0,To.current=null,n===null||n.return===null){b=1,er=t,q=null;break}e:{var i=e,o=n.return,u=n,s=t;if(t=ie,u.flags|=32768,s!==null&&typeof s=="object"&&typeof s.then=="function"){var c=s,y=u,f=y.tag;if(!(y.mode&1)&&(f===0||f===11||f===15)){var v=y.alternate;v?(y.updateQueue=v.updateQueue,y.memoizedState=v.memoizedState,y.lanes=v.lanes):(y.updateQueue=null,y.memoizedState=null)}var g=Fu(o);if(g!==null){g.flags&=-257,Ru(g,o,u,i,t),g.mode&1&&Iu(i,c,t),t=g,s=c;var w=t.updateQueue;if(w===null){var k=new Set;k.add(s),t.updateQueue=k}else w.add(s);break e}else{if(!(t&1)){Iu(i,c,t),Fo();break e}s=Error(x(426))}}else if(V&&u.mode&1){var M=Fu(o);if(M!==null){!(M.flags&65536)&&(M.flags|=256),Ru(M,o,u,i,t),mo(sn(s,u));break e}}i=s=sn(s,u),b!==4&&(b=2),An===null?An=[i]:An.push(i),i=o;do{switch(i.tag){case 3:i.flags|=65536,t&=-t,i.lanes|=t;var p=Da(i,s,t);_u(i,p);break e;case 1:u=s;var d=i.type,h=i.stateNode;if(!(i.flags&128)&&(typeof d.getDerivedStateFromError=="function"||h!==null&&typeof h.componentDidCatch=="function"&&(pt===null||!pt.has(h)))){i.flags|=65536,t&=-t,i.lanes|=t;var S=$a(i,u,t);_u(i,S);break e}}i=i.return}while(i!==null)}lc(n)}catch(C){t=C,q===n&&n!==null&&(q=n=n.return);continue}break}while(1)}function nc(){var e=nl.current;return nl.current=tl,e===null?tl:e}function Fo(){(b===0||b===3||b===2)&&(b=4),re===null||!(It&268435455)&&!(vl&268435455)||it(re,ie)}function il(e,t){var n=R;R|=2;var r=nc();(re!==e||ie!==t)&&(We=null,Ot(e,t));do try{qd();break}catch(l){tc(e,l)}while(1);if(ho(),R=n,nl.current=r,q!==null)throw Error(x(261));return re=null,ie=0,b}function qd(){for(;q!==null;)rc(q)}function Jd(){for(;q!==null&&!Ef();)rc(q)}function rc(e){var t=oc(e.alternate,e,Se);e.memoizedProps=e.pendingProps,t===null?lc(e):q=t,To.current=null}function lc(e){var t=e;do{var n=t.alternate;if(e=t.return,t.flags&32768){if(n=Wd(n,t),n!==null){n.flags&=32767,q=n;return}if(e!==null)e.flags|=32768,e.subtreeFlags=0,e.deletions=null;else{b=6,q=null;return}}else if(n=Hd(n,t,Se),n!==null){q=n;return}if(t=t.sibling,t!==null){q=t;return}q=t=e}while(t!==null);b===0&&(b=5)}function Ct(e,t,n){var r=A,l=Te.transition;try{Te.transition=null,A=1,bd(e,t,n,r)}finally{Te.transition=l,A=r}return null}function bd(e,t,n,r){do tn();while(ut!==null);if(R&6)throw Error(x(327));n=e.finishedWork;var l=e.finishedLanes;if(n===null)return null;if(e.finishedWork=null,e.finishedLanes=0,n===e.current)throw Error(x(177));e.callbackNode=null,e.callbackPriority=0;var i=n.lanes|n.childLanes;if(If(e,i),e===re&&(q=re=null,ie=0),!(n.subtreeFlags&2064)&&!(n.flags&2064)||Er||(Er=!0,uc(Ur,function(){return tn(),null})),i=(n.flags&15990)!==0,n.subtreeFlags&15990||i){i=Te.transition,Te.transition=null;var o=A;A=1;var u=R;R|=4,To.current=null,Yd(e,n),Ja(n,e),wd(xi),Br=!!Si,xi=Si=null,e.current=n,Xd(n),Cf(),R=u,A=o,Te.transition=i}else e.current=n;if(Er&&(Er=!1,ut=e,ll=l),i=e.pendingLanes,i===0&&(pt=null),Nf(n.stateNode),we(e,G()),t!==null)for(r=e.onRecoverableError,n=0;n<t.length;n++)l=t[n],r(l.value,{componentStack:l.stack,digest:l.digest});if(rl)throw rl=!1,e=Vi,Vi=null,e;return ll&1&&e.tag!==0&&tn(),i=e.pendingLanes,i&1?e===Bi?Mn++:(Mn=0,Bi=e):Mn=0,St(),null}function tn(){if(ut!==null){var e=Ms(ll),t=Te.transition,n=A;try{if(Te.transition=null,A=16>e?16:e,ut===null)var r=!1;else{if(e=ut,ut=null,ll=0,R&6)throw Error(x(331));var l=R;for(R|=4,E=e.current;E!==null;){var i=E,o=i.child;if(E.flags&16){var u=i.deletions;if(u!==null){for(var s=0;s<u.length;s++){var c=u[s];for(E=c;E!==null;){var y=E;switch(y.tag){case 0:case 11:case 15:Rn(8,y,i)}var f=y.child;if(f!==null)f.return=y,E=f;else for(;E!==null;){y=E;var v=y.sibling,g=y.return;if(Ga(y),y===c){E=null;break}if(v!==null){v.return=g,E=v;break}E=g}}}var w=i.alternate;if(w!==null){var k=w.child;if(k!==null){w.child=null;do{var M=k.sibling;k.sibling=null,k=M}while(k!==null)}}E=i}}if(i.subtreeFlags&2064&&o!==null)o.return=i,E=o;else e:for(;E!==null;){if(i=E,i.flags&2048)switch(i.tag){case 0:case 11:case 15:Rn(9,i,i.return)}var p=i.sibling;if(p!==null){p.return=i.return,E=p;break e}E=i.return}}var d=e.current;for(E=d;E!==null;){o=E;var h=o.child;if(o.subtreeFlags&2064&&h!==null)h.return=o,E=h;else e:for(o=d;E!==null;){if(u=E,u.flags&2048)try{switch(u.tag){case 0:case 11:case 15:hl(9,u)}}catch(C){K(u,u.return,C)}if(u===o){E=null;break e}var S=u.sibling;if(S!==null){S.return=u.return,E=S;break e}E=u.return}}if(R=l,St(),Qe&&typeof Qe.onPostCommitFiberRoot=="function")try{Qe.onPostCommitFiberRoot(sl,e)}catch{}r=!0}return r}finally{A=n,Te.transition=t}}return!1}function Xu(e,t,n){t=sn(n,t),t=Da(e,t,1),e=dt(e,t,1),t=de(),e!==null&&(nr(e,1,t),we(e,t))}function K(e,t,n){if(e.tag===3)Xu(e,e,n);else for(;t!==null;){if(t.tag===3){Xu(t,e,n);break}else if(t.tag===1){var r=t.stateNode;if(typeof t.type.getDerivedStateFromError=="function"||typeof r.componentDidCatch=="function"&&(pt===null||!pt.has(r))){e=sn(n,e),e=$a(t,e,1),t=dt(t,e,1),e=de(),t!==null&&(nr(t,1,e),we(t,e));break}}t=t.return}}function ep(e,t,n){var r=e.pingCache;r!==null&&r.delete(t),t=de(),e.pingedLanes|=e.suspendedLanes&n,re===e&&(ie&n)===n&&(b===4||b===3&&(ie&130023424)===ie&&500>G()-zo?Ot(e,0):Po|=n),we(e,t)}function ic(e,t){t===0&&(e.mode&1?(t=pr,pr<<=1,!(pr&130023424)&&(pr=4194304)):t=1);var n=de();e=Je(e,t),e!==null&&(nr(e,t,n),we(e,n))}function tp(e){var t=e.memoizedState,n=0;t!==null&&(n=t.retryLane),ic(e,n)}function np(e,t){var n=0;switch(e.tag){case 13:var r=e.stateNode,l=e.memoizedState;l!==null&&(n=l.retryLane);break;case 19:r=e.stateNode;break;default:throw Error(x(314))}r!==null&&r.delete(t),ic(e,n)}var oc;oc=function(e,t,n){if(e!==null)if(e.memoizedProps!==t.pendingProps||ve.current)he=!0;else{if(!(e.lanes&n)&&!(t.flags&128))return he=!1,Qd(e,t,n);he=!!(e.flags&131072)}else he=!1,V&&t.flags&1048576&&aa(t,Gr,t.index);switch(t.lanes=0,t.tag){case 2:var r=t.type;Ir(e,t),e=t.pendingProps;var l=rn(t,ce.current);en(t,n),l=Co(null,t,r,e,l,n);var i=jo();return t.flags|=1,typeof l=="object"&&l!==null&&typeof l.render=="function"&&l.$$typeof===void 0?(t.tag=1,t.memoizedState=null,t.updateQueue=null,ge(r)?(i=!0,Yr(t)):i=!1,t.memoizedState=l.state!==null&&l.state!==void 0?l.state:null,wo(t),l.updater=ml,t.stateNode=l,l._reactInternals=t,Pi(t,r,e,n),t=Ii(null,t,r,!0,i,n)):(t.tag=0,V&&i&&fo(t),fe(null,t,l,n),t=t.child),t;case 16:r=t.elementType;e:{switch(Ir(e,t),e=t.pendingProps,l=r._init,r=l(r._payload),t.type=r,l=t.tag=lp(r),e=Fe(r,e),l){case 0:t=Li(null,t,r,e,n);break e;case 1:t=Du(null,t,r,e,n);break e;case 11:t=Au(null,t,r,e,n);break e;case 14:t=Mu(null,t,r,Fe(r.type,e),n);break e}throw Error(x(306,r,""))}return t;case 0:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:Fe(r,l),Li(e,t,r,l,n);case 1:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:Fe(r,l),Du(e,t,r,l,n);case 3:e:{if(Qa(t),e===null)throw Error(x(387));r=t.pendingProps,i=t.memoizedState,l=i.element,pa(e,t),Jr(t,r,null,n);var o=t.memoizedState;if(r=o.element,i.isDehydrated)if(i={element:r,isDehydrated:!1,cache:o.cache,pendingSuspenseBoundaries:o.pendingSuspenseBoundaries,transitions:o.transitions},t.updateQueue.baseState=i,t.memoizedState=i,t.flags&256){l=sn(Error(x(423)),t),t=$u(e,t,r,n,l);break e}else if(r!==l){l=sn(Error(x(424)),t),t=$u(e,t,r,n,l);break e}else for(xe=ft(t.stateNode.containerInfo.firstChild),ke=t,V=!0,Ae=null,n=va(t,null,r,n),t.child=n;n;)n.flags=n.flags&-3|4096,n=n.sibling;else{if(ln(),r===l){t=be(e,t,n);break e}fe(e,t,r,n)}t=t.child}return t;case 5:return ga(t),e===null&&Ni(t),r=t.type,l=t.pendingProps,i=e!==null?e.memoizedProps:null,o=l.children,ki(r,l)?o=null:i!==null&&ki(r,i)&&(t.flags|=32),Ba(e,t),fe(e,t,o,n),t.child;case 6:return e===null&&Ni(t),null;case 13:return Ha(e,t,n);case 4:return So(t,t.stateNode.containerInfo),r=t.pendingProps,e===null?t.child=on(t,null,r,n):fe(e,t,r,n),t.child;case 11:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:Fe(r,l),Au(e,t,r,l,n);case 7:return fe(e,t,t.pendingProps,n),t.child;case 8:return fe(e,t,t.pendingProps.children,n),t.child;case 12:return fe(e,t,t.pendingProps.children,n),t.child;case 10:e:{if(r=t.type._context,l=t.pendingProps,i=t.memoizedProps,o=l.value,D(Zr,r._currentValue),r._currentValue=o,i!==null)if($e(i.value,o)){if(i.children===l.children&&!ve.current){t=be(e,t,n);break e}}else for(i=t.child,i!==null&&(i.return=t);i!==null;){var u=i.dependencies;if(u!==null){o=i.child;for(var s=u.firstContext;s!==null;){if(s.context===r){if(i.tag===1){s=Ge(-1,n&-n),s.tag=2;var c=i.updateQueue;if(c!==null){c=c.shared;var y=c.pending;y===null?s.next=s:(s.next=y.next,y.next=s),c.pending=s}}i.lanes|=n,s=i.alternate,s!==null&&(s.lanes|=n),Oi(i.return,n,t),u.lanes|=n;break}s=s.next}}else if(i.tag===10)o=i.type===t.type?null:i.child;else if(i.tag===18){if(o=i.return,o===null)throw Error(x(341));o.lanes|=n,u=o.alternate,u!==null&&(u.lanes|=n),Oi(o,n,t),o=i.sibling}else o=i.child;if(o!==null)o.return=i;else for(o=i;o!==null;){if(o===t){o=null;break}if(i=o.sibling,i!==null){i.return=o.return,o=i;break}o=o.return}i=o}fe(e,t,l.children,n),t=t.child}return t;case 9:return l=t.type,r=t.pendingProps.children,en(t,n),l=Pe(l),r=r(l),t.flags|=1,fe(e,t,r,n),t.child;case 14:return r=t.type,l=Fe(r,t.pendingProps),l=Fe(r.type,l),Mu(e,t,r,l,n);case 15:return Ua(e,t,t.type,t.pendingProps,n);case 17:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:Fe(r,l),Ir(e,t),t.tag=1,ge(r)?(e=!0,Yr(t)):e=!1,en(t,n),ya(t,r,l),Pi(t,r,l,n),Ii(null,t,r,!0,e,n);case 19:return Wa(e,t,n);case 22:return Va(e,t,n)}throw Error(x(156,t.tag))};function uc(e,t){return Is(e,t)}function rp(e,t,n,r){this.tag=e,this.key=n,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.ref=null,this.pendingProps=t,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=r,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function Oe(e,t,n,r){return new rp(e,t,n,r)}function Ro(e){return e=e.prototype,!(!e||!e.isReactComponent)}function lp(e){if(typeof e=="function")return Ro(e)?1:0;if(e!=null){if(e=e.$$typeof,e===bi)return 11;if(e===eo)return 14}return 2}function yt(e,t){var n=e.alternate;return n===null?(n=Oe(e.tag,t,e.key,e.mode),n.elementType=e.elementType,n.type=e.type,n.stateNode=e.stateNode,n.alternate=e,e.alternate=n):(n.pendingProps=t,n.type=e.type,n.flags=0,n.subtreeFlags=0,n.deletions=null),n.flags=e.flags&14680064,n.childLanes=e.childLanes,n.lanes=e.lanes,n.child=e.child,n.memoizedProps=e.memoizedProps,n.memoizedState=e.memoizedState,n.updateQueue=e.updateQueue,t=e.dependencies,n.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext},n.sibling=e.sibling,n.index=e.index,n.ref=e.ref,n}function Ar(e,t,n,r,l,i){var o=2;if(r=e,typeof e=="function")Ro(e)&&(o=1);else if(typeof e=="string")o=5;else e:switch(e){case $t:return Tt(n.children,l,i,t);case Ji:o=8,l|=8;break;case ei:return e=Oe(12,n,t,l|2),e.elementType=ei,e.lanes=i,e;case ti:return e=Oe(13,n,t,l),e.elementType=ti,e.lanes=i,e;case ni:return e=Oe(19,n,t,l),e.elementType=ni,e.lanes=i,e;case hs:return gl(n,l,i,t);default:if(typeof e=="object"&&e!==null)switch(e.$$typeof){case ms:o=10;break e;case ys:o=9;break e;case bi:o=11;break e;case eo:o=14;break e;case nt:o=16,r=null;break e}throw Error(x(130,e==null?e:typeof e,""))}return t=Oe(o,n,t,l),t.elementType=e,t.type=r,t.lanes=i,t}function Tt(e,t,n,r){return e=Oe(7,e,r,t),e.lanes=n,e}function gl(e,t,n,r){return e=Oe(22,e,r,t),e.elementType=hs,e.lanes=n,e.stateNode={isHidden:!1},e}function Zl(e,t,n){return e=Oe(6,e,null,t),e.lanes=n,e}function ql(e,t,n){return t=Oe(4,e.children!==null?e.children:[],e.key,t),t.lanes=n,t.stateNode={containerInfo:e.containerInfo,pendingChildren:null,implementation:e.implementation},t}function ip(e,t,n,r,l){this.tag=t,this.containerInfo=e,this.finishedWork=this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.pendingContext=this.context=null,this.callbackPriority=0,this.eventTimes=zl(0),this.expirationTimes=zl(-1),this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=zl(0),this.identifierPrefix=r,this.onRecoverableError=l,this.mutableSourceEagerHydrationData=null}function Ao(e,t,n,r,l,i,o,u,s){return e=new ip(e,t,n,u,s),t===1?(t=1,i===!0&&(t|=8)):t=0,i=Oe(3,null,null,t),e.current=i,i.stateNode=e,i.memoizedState={element:r,isDehydrated:n,cache:null,transitions:null,pendingSuspenseBoundaries:null},wo(i),e}function op(e,t,n){var r=3<arguments.length&&arguments[3]!==void 0?arguments[3]:null;return{$$typeof:Dt,key:r==null?null:""+r,children:e,containerInfo:t,implementation:n}}function sc(e){if(!e)return vt;e=e._reactInternals;e:{if(At(e)!==e||e.tag!==1)throw Error(x(170));var t=e;do{switch(t.tag){case 3:t=t.stateNode.context;break e;case 1:if(ge(t.type)){t=t.stateNode.__reactInternalMemoizedMergedChildContext;break e}}t=t.return}while(t!==null);throw Error(x(171))}if(e.tag===1){var n=e.type;if(ge(n))return ua(e,n,t)}return t}function ac(e,t,n,r,l,i,o,u,s){return e=Ao(n,r,!0,e,l,i,o,u,s),e.context=sc(null),n=e.current,r=de(),l=mt(n),i=Ge(r,l),i.callback=t??null,dt(n,i,l),e.current.lanes=l,nr(e,l,r),we(e,r),e}function wl(e,t,n,r){var l=t.current,i=de(),o=mt(l);return n=sc(n),t.context===null?t.context=n:t.pendingContext=n,t=Ge(i,o),t.payload={element:e},r=r===void 0?null:r,r!==null&&(t.callback=r),e=dt(l,t,o),e!==null&&(De(e,l,o,i),Pr(e,l,o)),o}function ol(e){if(e=e.current,!e.child)return null;switch(e.child.tag){case 5:return e.child.stateNode;default:return e.child.stateNode}}function Gu(e,t){if(e=e.memoizedState,e!==null&&e.dehydrated!==null){var n=e.retryLane;e.retryLane=n!==0&&n<t?n:t}}function Mo(e,t){Gu(e,t),(e=e.alternate)&&Gu(e,t)}function up(){return null}var cc=typeof reportError=="function"?reportError:function(e){console.error(e)};function Do(e){this._internalRoot=e}Sl.prototype.render=Do.prototype.render=function(e){var t=this._internalRoot;if(t===null)throw Error(x(409));wl(e,t,null,null)};Sl.prototype.unmount=Do.prototype.unmount=function(){var e=this._internalRoot;if(e!==null){this._internalRoot=null;var t=e.containerInfo;Ft(function(){wl(null,e,null,null)}),t[qe]=null}};function Sl(e){this._internalRoot=e}Sl.prototype.unstable_scheduleHydration=function(e){if(e){var t=Us();e={blockedOn:null,target:e,priority:t};for(var n=0;n<lt.length&&t!==0&&t<lt[n].priority;n++);lt.splice(n,0,e),n===0&&Bs(e)}};function $o(e){return!(!e||e.nodeType!==1&&e.nodeType!==9&&e.nodeType!==11)}function xl(e){return!(!e||e.nodeType!==1&&e.nodeType!==9&&e.nodeType!==11&&(e.nodeType!==8||e.nodeValue!==" react-mount-point-unstable "))}function Zu(){}function sp(e,t,n,r,l){if(l){if(typeof r=="function"){var i=r;r=function(){var c=ol(o);i.call(c)}}var o=ac(t,r,e,0,null,!1,!1,"",Zu);return e._reactRootContainer=o,e[qe]=o.current,Kn(e.nodeType===8?e.parentNode:e),Ft(),o}for(;l=e.lastChild;)e.removeChild(l);if(typeof r=="function"){var u=r;r=function(){var c=ol(s);u.call(c)}}var s=Ao(e,0,!1,null,null,!1,!1,"",Zu);return e._reactRootContainer=s,e[qe]=s.current,Kn(e.nodeType===8?e.parentNode:e),Ft(function(){wl(t,s,n,r)}),s}function kl(e,t,n,r,l){var i=n._reactRootContainer;if(i){var o=i;if(typeof l=="function"){var u=l;l=function(){var s=ol(o);u.call(s)}}wl(t,o,e,l)}else o=sp(n,t,e,l,r);return ol(o)}Ds=function(e){switch(e.tag){case 3:var t=e.stateNode;if(t.current.memoizedState.isDehydrated){var n=Nn(t.pendingLanes);n!==0&&(ro(t,n|1),we(t,G()),!(R&6)&&(an=G()+500,St()))}break;case 13:Ft(function(){var r=Je(e,1);if(r!==null){var l=de();De(r,e,1,l)}}),Mo(e,1)}};lo=function(e){if(e.tag===13){var t=Je(e,134217728);if(t!==null){var n=de();De(t,e,134217728,n)}Mo(e,134217728)}};$s=function(e){if(e.tag===13){var t=mt(e),n=Je(e,t);if(n!==null){var r=de();De(n,e,t,r)}Mo(e,t)}};Us=function(){return A};Vs=function(e,t){var n=A;try{return A=e,t()}finally{A=n}};di=function(e,t,n){switch(t){case"input":if(ii(e,n),t=n.name,n.type==="radio"&&t!=null){for(n=e;n.parentNode;)n=n.parentNode;for(n=n.querySelectorAll("input[name="+JSON.stringify(""+t)+'][type="radio"]'),t=0;t<n.length;t++){var r=n[t];if(r!==e&&r.form===e.form){var l=dl(r);if(!l)throw Error(x(90));gs(r),ii(r,l)}}}break;case"textarea":Ss(e,n);break;case"select":t=n.value,t!=null&&Zt(e,!!n.multiple,t,!1)}};Ns=Lo;Os=Ft;var ap={usingClientEntryPoint:!1,Events:[lr,Qt,dl,js,_s,Lo]},Cn={findFiberByHostInstance:jt,bundleType:0,version:"18.2.0",rendererPackageName:"react-dom"},cp={bundleType:Cn.bundleType,version:Cn.version,rendererPackageName:Cn.rendererPackageName,rendererConfig:Cn.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:et.ReactCurrentDispatcher,findHostInstanceByFiber:function(e){return e=zs(e),e===null?null:e.stateNode},findFiberByHostInstance:Cn.findFiberByHostInstance||up,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.2.0-next-9e3b772b8-20220608"};if(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__<"u"){var Cr=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!Cr.isDisabled&&Cr.supportsFiber)try{sl=Cr.inject(cp),Qe=Cr}catch{}}Ce.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ap;Ce.createPortal=function(e,t){var n=2<arguments.length&&arguments[2]!==void 0?arguments[2]:null;if(!$o(t))throw Error(x(200));return op(e,t,null,n)};Ce.createRoot=function(e,t){if(!$o(e))throw Error(x(299));var n=!1,r="",l=cc;return t!=null&&(t.unstable_strictMode===!0&&(n=!0),t.identifierPrefix!==void 0&&(r=t.identifierPrefix),t.onRecoverableError!==void 0&&(l=t.onRecoverableError)),t=Ao(e,1,!1,null,null,n,!1,r,l),e[qe]=t.current,Kn(e.nodeType===8?e.parentNode:e),new Do(t)};Ce.findDOMNode=function(e){if(e==null)return null;if(e.nodeType===1)return e;var t=e._reactInternals;if(t===void 0)throw typeof e.render=="function"?Error(x(188)):(e=Object.keys(e).join(","),Error(x(268,e)));return e=zs(t),e=e===null?null:e.stateNode,e};Ce.flushSync=function(e){return Ft(e)};Ce.hydrate=function(e,t,n){if(!xl(t))throw Error(x(200));return kl(null,e,t,!0,n)};Ce.hydrateRoot=function(e,t,n){if(!$o(e))throw Error(x(405));var r=n!=null&&n.hydratedSources||null,l=!1,i="",o=cc;if(n!=null&&(n.unstable_strictMode===!0&&(l=!0),n.identifierPrefix!==void 0&&(i=n.identifierPrefix),n.onRecoverableError!==void 0&&(o=n.onRecoverableError)),t=ac(t,null,e,1,n??null,l,!1,i,o),e[qe]=t.current,Kn(e),r)for(e=0;e<r.length;e++)n=r[e],l=n._getVersion,l=l(n._source),t.mutableSourceEagerHydrationData==null?t.mutableSourceEagerHydrationData=[n,l]:t.mutableSourceEagerHydrationData.push(n,l);return new Sl(t)};Ce.render=function(e,t,n){if(!xl(t))throw Error(x(200));return kl(null,e,t,!1,n)};Ce.unmountComponentAtNode=function(e){if(!xl(e))throw Error(x(40));return e._reactRootContainer?(Ft(function(){kl(null,null,e,!1,function(){e._reactRootContainer=null,e[qe]=null})}),!0):!1};Ce.unstable_batchedUpdates=Lo;Ce.unstable_renderSubtreeIntoContainer=function(e,t,n,r){if(!xl(n))throw Error(x(200));if(e==null||e._reactInternals===void 0)throw Error(x(38));return kl(e,t,n,!1,r)};Ce.version="18.2.0-next-9e3b772b8-20220608";function fc(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(fc)}catch(e){console.error(e)}}fc(),as.exports=Ce;var fp=as.exports,dc,qu=fp;dc=qu.createRoot,qu.hydrateRoot;var dp=(typeof process<"u","https://huggingface.co");async function pp(e,t){var r;const n=new mp(e.url,e.status,e.headers.get("X-Request-Id")??(t==null?void 0:t.requestId));if(n.message=`Api error with status ${n.statusCode}.${t!=null&&t.message?` ${t.message}.`:""} Request ID: ${n.requestId}, url: ${n.url}`,(r=e.headers.get("Content-Type"))!=null&&r.startsWith("application/json")){const l=await e.json();n.message=l.error||l.message||n.message,n.data=l}else n.data={message:await e.text()};throw n}var mp=class extends Error{constructor(t,n,r,l){super(l);hn(this,"statusCode");hn(this,"url");hn(this,"requestId");hn(this,"data");this.statusCode=n,this.requestId=r,this.url=t}};function yp(e){if(!(!e||e.accessToken===void 0||e.accessToken===null)&&!e.accessToken.startsWith("hf_"))throw new TypeError("Your access token must start with 'hf_'")}function hp(e){const t=/<(https?:[/][/][^>]+)>;\s+rel="([^"]+)"/g;return Object.fromEntries([...e.matchAll(t)].map(([,n,r])=>[r,n]))}var vp=["pipeline_tag","private","gated","downloads","likes"];async function*gp(e){var r,l;yp(e==null?void 0:e.credentials);const t=new URLSearchParams([...Object.entries({limit:"500",...(r=e==null?void 0:e.search)!=null&&r.owner?{author:e.search.owner}:void 0,...(l=e==null?void 0:e.search)!=null&&l.task?{pipeline_tag:e.search.task}:void 0}),...vp.map(i=>["expand",i])]).toString();let n=`${(e==null?void 0:e.hubUrl)||dp}/api/models?${t}`;for(;n;){const i=await fetch(n,{headers:{accept:"application/json",...e!=null&&e.credentials?{Authorization:`Bearer ${e.credentials.accessToken}`}:void 0}});if(!i.ok)throw pp(i);const o=await i.json();for(const s of o)yield{id:s._id,name:s.id,private:s.private,task:s.pipeline_tag,downloads:s.downloads,gated:s.gated,likes:s.likes,updatedAt:new Date(s.lastModified)};const u=i.headers.get("Link");n=u?hp(u).next:void 0}}var wp=Object.defineProperty,Sp=(e,t)=>{for(var n in t)wp(e,n,{get:t[n],enumerable:!0})},xp={};Sp(xp,{audioClassification:()=>mc,automaticSpeechRecognition:()=>yc,conversational:()=>xc,documentQuestionAnswering:()=>Fc,featureExtraction:()=>kc,fillMask:()=>Ec,imageClassification:()=>hc,imageSegmentation:()=>vc,imageToText:()=>gc,objectDetection:()=>wc,questionAnswering:()=>Cc,request:()=>W,sentenceSimilarity:()=>jc,streamingRequest:()=>Uo,summarization:()=>_c,tableQuestionAnswering:()=>Nc,textClassification:()=>Oc,textGeneration:()=>Tc,textGenerationStream:()=>_p,textToImage:()=>Sc,tokenClassification:()=>Pc,translation:()=>zc,visualQuestionAnswering:()=>Rc,zeroShotClassification:()=>Lc});var kp="https://api-inference.huggingface.co/models/";function pc(e,t){const{model:n,accessToken:r,...l}=e,i={};r&&(i.Authorization=`Bearer ${r}`);const o="data"in e&&!!e.data;o?(t!=null&&t.wait_for_model&&(i["X-Wait-For-Model"]="true"),(t==null?void 0:t.use_cache)===!1&&(i["X-Use-Cache"]="false"),t!=null&&t.dont_load_model&&(i["X-Load-Model"]="0")):i["Content-Type"]="application/json";const u=/^http(s?):/.test(n)||n.startsWith("/")?n:`${kp}${n}`,s={headers:i,method:"POST",body:o?e.data:JSON.stringify({...l,options:t}),credentials:t!=null&&t.includeCredentials?"include":"same-origin"};return{url:u,info:s}}async function W(e,t){var i,o;const{url:n,info:r}=pc(e,t),l=await((t==null?void 0:t.fetch)??fetch)(n,r);if((t==null?void 0:t.retry_on_error)!==!1&&l.status===503&&!(t!=null&&t.wait_for_model))return W(e,{...t,wait_for_model:!0});if(!l.ok){if((i=l.headers.get("Content-Type"))!=null&&i.startsWith("application/json")){const u=await l.json();if(u.error)throw new Error(u.error)}throw new Error("An error occurred while fetching the blob")}return(o=l.headers.get("Content-Type"))!=null&&o.startsWith("application/json")?await l.json():await l.blob()}function Ep(e){let t,n,r,l=!1;return function(o){t===void 0?(t=o,n=0,r=-1):t=jp(t,o);const u=t.length;let s=0;for(;n<u;){l&&(t[n]===10&&(s=++n),l=!1);let c=-1;for(;n<u&&c===-1;++n)switch(t[n]){case 58:r===-1&&(r=n-s);break;case 13:l=!0;case 10:c=n;break}if(c===-1)break;e(t.subarray(s,c),r),s=n,r=-1}s===u?t=void 0:s!==0&&(t=t.subarray(s),n-=s)}}function Cp(e,t,n){let r=Ju();const l=new TextDecoder;return function(o,u){if(o.length===0)n==null||n(r),r=Ju();else if(u>0){const s=l.decode(o.subarray(0,u)),c=u+(o[u+1]===32?2:1),y=l.decode(o.subarray(c));switch(s){case"data":r.data=r.data?r.data+`
-`+y:y;break;case"event":r.event=y;break;case"id":e(r.id=y);break;case"retry":const f=parseInt(y,10);isNaN(f)||t(r.retry=f);break}}}}function jp(e,t){const n=new Uint8Array(e.length+t.length);return n.set(e),n.set(t,e.length),n}function Ju(){return{data:"",event:"",id:"",retry:void 0}}async function*Uo(e,t){var c;const{url:n,info:r}=pc({...e,stream:!0},t),l=await((t==null?void 0:t.fetch)??fetch)(n,r);if((t==null?void 0:t.retry_on_error)!==!1&&l.status===503&&!(t!=null&&t.wait_for_model))return Uo(e,{...t,wait_for_model:!0});if(!l.ok){if((c=l.headers.get("Content-Type"))!=null&&c.startsWith("application/json")){const y=await l.json();if(y.error)throw new Error(y.error)}throw new Error(`Server response contains error: ${l.status}`)}if(l.headers.get("content-type")!=="text/event-stream")throw new Error("Server does not support event stream content type, it returned "+l.headers.get("content-type"));if(!l.body)return;const i=l.body.getReader();let o=[];const s=Ep(Cp(()=>{},()=>{},y=>{o.push(y)}));try{for(;;){const{done:y,value:f}=await i.read();if(y)return;s(f);for(const v of o)v.data.length>0&&(yield JSON.parse(v.data));o=[]}}finally{i.releaseLock()}}var Z=class extends TypeError{constructor(e){super(`Invalid inference output: ${e}. Use the 'request' method with the same parameters to do a custom call with no type checking.`),this.name="InferenceOutputError"}};async function mc(e,t){const n=await W(e,t);if(!(Array.isArray(n)&&n.every(l=>typeof l.label=="string"&&typeof l.score=="number")))throw new Z("Expected Array<{label: string, score: number}>");return n}async function yc(e,t){const n=await W(e,t);if(!(typeof(n==null?void 0:n.text)=="string"))throw new Z("Expected {text: string}");return n}async function hc(e,t){const n=await W(e,t);if(!(Array.isArray(n)&&n.every(l=>typeof l.label=="string"&&typeof l.score=="number")))throw new Z("Expected Array<{label: string, score: number}>");return n}async function vc(e,t){const n=await W(e,t);if(!(Array.isArray(n)&&n.every(l=>typeof l.label=="string"&&typeof l.mask=="string"&&typeof l.score=="number")))throw new Z("Expected Array<{label: string, mask: string, score: number}>");return n}async function gc(e,t){var r;const n=(r=await W(e,t))==null?void 0:r[0];if(typeof(n==null?void 0:n.generated_text)!="string")throw new Z("Expected {generated_text: string}");return n}async function wc(e,t){const n=await W(e,t);if(!(Array.isArray(n)&&n.every(l=>typeof l.label=="string"&&typeof l.score=="number"&&typeof l.box.xmin=="number"&&typeof l.box.ymin=="number"&&typeof l.box.xmax=="number"&&typeof l.box.ymax=="number")))throw new Z("Expected Array<{label:string; score:number; box:{xmin:number; ymin:number; xmax:number; ymax:number}}>");return n}async function Sc(e,t){const n=await W(e,t);if(!(n&&n instanceof Blob))throw new Z("Expected Blob");return n}async function xc(e,t){const n=await W(e,t);if(!(Array.isArray(n.conversation.generated_responses)&&n.conversation.generated_responses.every(l=>typeof l=="string")&&Array.isArray(n.conversation.past_user_inputs)&&n.conversation.past_user_inputs.every(l=>typeof l=="string")&&typeof n.generated_text=="string"&&Array.isArray(n.warnings)&&n.warnings.every(l=>typeof l=="string")))throw new Z("Expected {conversation: {generated_responses: string[], past_user_inputs: string[]}, generated_text: string, warnings: string[]}");return n}async function kc(e,t){const n=await W(e,t);let r=!0;if(Array.isArray(n)){for(const l of n)if(Array.isArray(l)){if(r=l.every(i=>typeof i=="number"),!r)break}else if(typeof l!="number"){r=!1;break}}else r=!1;if(!r)throw new Z("Expected Array<number[] | number>");return n}async function Ec(e,t){const n=await W(e,t);if(!(Array.isArray(n)&&n.every(l=>typeof l.score=="number"&&typeof l.sequence=="string"&&typeof l.token=="number"&&typeof l.token_str=="string")))throw new Z("Expected Array<{score: number, sequence: string, token: number, token_str: string}>");return n}async function Cc(e,t){const n=await W(e,t);if(!(typeof n=="object"&&!!n&&typeof n.answer=="string"&&typeof n.end=="number"&&typeof n.score=="number"&&typeof n.start=="number"))throw new Z("Expected {answer: string, end: number, score: number, start: number}");return n}async function jc(e,t){const n=await W(e,t);if(!(Array.isArray(n)&&n.every(l=>typeof l=="number")))throw new Z("Expected number[]");return n}async function _c(e,t){const n=await W(e,t);if(!(Array.isArray(n)&&n.every(l=>typeof(l==null?void 0:l.summary_text)=="string")))throw new Z("Expected Array<{summary_text: string}>");return n==null?void 0:n[0]}async function Nc(e,t){const n=await W(e,t);if(!(typeof(n==null?void 0:n.aggregator)=="string"&&typeof n.answer=="string"&&Array.isArray(n.cells)&&n.cells.every(l=>typeof l=="string")&&Array.isArray(n.coordinates)&&n.coordinates.every(l=>Array.isArray(l)&&l.every(i=>typeof i=="number"))))throw new Z("Expected {aggregator: string, answer: string, cells: string[], coordinates: number[][]}");return n}async function Oc(e,t){var l;const n=(l=await W(e,t))==null?void 0:l[0];if(!(Array.isArray(n)&&n.every(i=>typeof(i==null?void 0:i.label)=="string"&&typeof i.score=="number")))throw new Z("Expected Array<{label: string, score: number}>");return n}async function Tc(e,t){const n=await W(e,t);if(!(Array.isArray(n)&&n.every(l=>typeof(l==null?void 0:l.generated_text)=="string")))throw new Z("Expected Array<{generated_text: string}>");return n==null?void 0:n[0]}async function*_p(e,t){yield*Uo(e,t)}function Vo(e){return Array.isArray(e)?e:[e]}async function Pc(e,t){const n=Vo(await W(e,t));if(!(Array.isArray(n)&&n.every(l=>typeof l.end=="number"&&typeof l.entity_group=="string"&&typeof l.score=="number"&&typeof l.start=="number"&&typeof l.word=="string")))throw new Z("Expected Array<{end: number, entity_group: string, score: number, start: number, word: string}>");return n}async function zc(e,t){const n=await W(e,t);if(!(Array.isArray(n)&&n.every(l=>typeof(l==null?void 0:l.translation_text)=="string")))throw new Z("Expected type Array<{translation_text: string}>");return n==null?void 0:n[0]}async function Lc(e,t){const n=Vo(await W(e,t));if(!(Array.isArray(n)&&n.every(l=>Array.isArray(l.labels)&&l.labels.every(i=>typeof i=="string")&&Array.isArray(l.scores)&&l.scores.every(i=>typeof i=="number")&&typeof l.sequence=="string")))throw new Z("Expected Array<{labels: string[], scores: number[], sequence: string}>");return n}function Ic(e){if(globalThis.Buffer)return globalThis.Buffer.from(e).toString("base64");{const t=[];return e.forEach(n=>{t.push(String.fromCharCode(n))}),globalThis.btoa(t.join(""))}}async function Fc(e,t){var i;const n={...e,inputs:{question:e.inputs.question,image:Ic(new Uint8Array(await e.inputs.image.arrayBuffer()))}},r=(i=Vo(await W(n,t)))==null?void 0:i[0];if(!(typeof(r==null?void 0:r.answer)=="string"&&(typeof r.end=="number"||typeof r.end>"u")&&(typeof r.score=="number"||typeof r.score>"u")&&(typeof r.start=="number"||typeof r.start>"u")))throw new Z("Expected Array<{answer: string, end?: number, score?: number, start?: number}>");return r}async function Rc(e,t){var i;const n={...e,inputs:{question:e.inputs.question,image:Ic(new Uint8Array(await e.inputs.image.arrayBuffer()))}},r=(i=await W(n,t))==null?void 0:i[0];if(!(typeof(r==null?void 0:r.answer)=="string"&&typeof r.score=="number"))throw new Z("Expected Array<{answer: string, score: number}>");return r}const T=e=>a.jsx("button",{className:`${e.variant==="secondary"?"border-4 border-yellow-200":"bg-yellow-200"} py-6 text-center w-full ${e.disabled?"cursor-not-allowed opacity-50":""}`,disabled:e.disabled??!1,onClick:e.onClick,children:e.label??"Submit"}),Ac=e=>a.jsxs("div",{className:"w-full",children:[a.jsx("p",{className:"text-xl",children:e.label??"Input"}),e.input?a.jsx("audio",{className:"w-full",controls:!0,src:URL.createObjectURL(e.input)}):a.jsxs("label",{className:"bg-yellow-200 block cursor-pointer py-6 text-center w-full",children:["No file chosen",a.jsx("input",{accept:"audio/*",className:"hidden",onChange:t=>{t.target.files&&t.target.files[0]&&e.setInput(t.target.files[0])},type:"file"})]})]}),z=e=>{const t=(()=>{try{return JSON.stringify(e.output,void 0,2)}catch(n){if(n instanceof Error)return`Error during JSON.stringify: ${n.message}`}})();return a.jsxs("div",{className:"w-full",children:[a.jsx("p",{className:"text-xl",children:e.label??"Output"}),a.jsx("pre",{className:`bg-yellow-200 break-words p-6 select-text w-full whitespace-pre-wrap ${e.disabled?"cursor-wait opacity-50":""}`,children:t})]})},Np="audio-classification",Op=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await mc({data:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(Ac,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?u.map(f=>a.jsx(z,{disabled:r,output:f},f.label)):a.jsx(m.Fragment,{})]})},Tp="automatic-speech-recognition",Pp=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await yc({data:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(Ac,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?a.jsx(z,{disabled:r,output:u}):a.jsx(m.Fragment,{})]})},ee=e=>a.jsxs("div",{className:"w-full",children:[a.jsx("p",{className:"text-xl",children:e.label??"Input"}),e.variant==="textarea"?a.jsx("textarea",{className:"bg-yellow-200 py-6 text-center w-full",disabled:e.disabled??!1,onChange:t=>{!e.disabled&&!e.readOnly&&e.setInput&&(t.target.value?e.setInput(t.target.value):e.setInput(""))},readOnly:e.readOnly,value:e.input??""}):a.jsx("input",{className:"bg-yellow-200 py-6 text-center w-full",disabled:e.disabled??!1,onChange:t=>{!e.disabled&&!e.readOnly&&e.setInput&&(t.target.value?e.setInput(t.target.value):e.setInput(""))},readOnly:e.readOnly,type:"text",value:e.input??""})]}),zp="conversational",Lp=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=()=>{t&&(l(!0),s(f=>f?{...f,conversation:{...f.conversation,past_user_inputs:[...f.conversation.past_user_inputs,t]}}:{conversation:{generated_responses:[],past_user_inputs:[t]},generated_text:"",warnings:[]}),n(void 0),xc({inputs:{generated_responses:u==null?void 0:u.conversation.generated_responses,past_user_inputs:u==null?void 0:u.conversation.past_user_inputs,text:t},model:e.model}).then(s).catch(o).finally(()=>l(!1)))};return a.jsxs(m.Fragment,{children:[!i&&u?Array.from({length:Math.max(u.conversation.generated_responses.length,u.conversation.past_user_inputs.length)}).map((f,v)=>a.jsxs(m.Fragment,{children:[u.conversation.past_user_inputs[v]?a.jsx(ee,{label:`Output - Past User Input #${v+1}`,input:u.conversation.past_user_inputs[v],readOnly:!0}):a.jsx(m.Fragment,{}),u.conversation.generated_responses[v]?a.jsx(z,{disabled:r,label:`Output - Generated Response #${v+1}`,output:u.conversation.generated_responses[v]}):a.jsx(m.Fragment,{})]},v)):a.jsx(m.Fragment,{}),a.jsx(ee,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{})]})},pn=e=>a.jsxs("div",{className:"w-full",children:[a.jsx("p",{className:"text-xl",children:e.label??"Input"}),e.input?a.jsx("img",{className:"w-full",src:URL.createObjectURL(e.input)}):a.jsxs("label",{className:"bg-yellow-200 block cursor-pointer py-6 text-center w-full",children:["No file chosen",a.jsx("input",{accept:"image/*",className:"hidden",onChange:t=>{t.target.files&&t.target.files[0]&&e.setInput(t.target.files[0])},type:"file"})]})]}),Ip="document-question-answering",Fp=e=>{const[t,n]=m.useState(),[r,l]=m.useState(),[i,o]=m.useState(!1),[u,s]=m.useState(),[c,y]=m.useState(),f=()=>{n(void 0),l(void 0),s(void 0),y(void 0)},v=async()=>{if(t&&r){o(!0);try{const g=await Fc({inputs:{question:t,image:r},model:e.model});y(g)}catch(g){g instanceof Error&&s(g)}finally{o(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,label:"Input - Question",setInput:n}),a.jsx(pn,{input:r,label:"Input - Image",setInput:l}),a.jsx(T,{label:"Clear",disabled:i||!r,onClick:f,variant:"secondary"}),a.jsx(T,{disabled:i||!r,onClick:v}),!i&&u?a.jsx(z,{disabled:i,output:u}):a.jsx(m.Fragment,{}),!u&&c?a.jsx(z,{disabled:i,output:c}):a.jsx(m.Fragment,{})]})},Rp="feature-extraction",Ap=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await kc({inputs:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?a.jsx(z,{disabled:r,output:u}):a.jsx(m.Fragment,{})]})},Mp="fill-mask",Dp=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await Ec({inputs:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?u.map(f=>a.jsx(z,{disabled:r,output:f},f.token_str)):a.jsx(m.Fragment,{})]})},$p="image-classification",Up=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await hc({data:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(pn,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?u.map(f=>a.jsx(z,{disabled:r,output:f},f.label)):a.jsx(m.Fragment,{})]})},Vp="image-segmentation",Bp=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await vc({data:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(pn,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?u.map(f=>a.jsx(z,{disabled:r,output:f},f.label)):a.jsx(m.Fragment,{})]})},Qp="image-to-text",Hp=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await gc({data:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(pn,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?a.jsx(z,{disabled:r,output:u}):a.jsx(m.Fragment,{})]})},Wp="object-detection",Kp=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await wc({data:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(pn,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?u.map(f=>a.jsx(z,{disabled:r,output:f},f.label)):a.jsx(m.Fragment,{})]})},Yp="question-answering",Xp=e=>{const[t,n]=m.useState(),[r,l]=m.useState(),[i,o]=m.useState(!1),[u,s]=m.useState(),[c,y]=m.useState(),f=()=>{n(void 0),l(void 0),s(void 0),y(void 0)},v=async()=>{if(t&&r){o(!0);try{const g=await Cc({inputs:{question:t,context:r},model:e.model});y(g)}catch(g){g instanceof Error&&s(g)}finally{o(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,label:"Input - Question",setInput:n}),a.jsx(ee,{input:r,label:"Input - Context",setInput:l,variant:"textarea"}),a.jsx(T,{label:"Clear",disabled:i||!t||!r,onClick:f,variant:"secondary"}),a.jsx(T,{disabled:i||!t||!r,onClick:v}),!i&&u?a.jsx(z,{disabled:i,output:u}):a.jsx(m.Fragment,{}),!u&&c?a.jsx(z,{disabled:i,output:c}):a.jsx(m.Fragment,{})]})},Gp="sentence-similarity",Zp=e=>{const[t,n]=m.useState(),r=Array.from({length:2}).map(()=>{}),[l,i]=m.useState(r),[o,u]=m.useState(!1),[s,c]=m.useState(),[y,f]=m.useState(),v=()=>{n(void 0),i(r),c(void 0),f(void 0)},g=async()=>{if(t&&l.every(Boolean)){u(!0);try{const w=await jc({inputs:{source_sentence:t,sentences:l},model:e.model});f(w)}catch(w){w instanceof Error&&c(w)}finally{u(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,label:"Input - Source Sentence",setInput:n}),l.map((w,k)=>a.jsx(ee,{input:w,label:`Input - Sentence #${k+1}`,setInput:M=>i(p=>[...p.slice(0,k),M,...p.slice(k+1,p.length)])})),a.jsx(T,{disabled:o||!t||!l.every(Boolean),label:"Add Sentence",onClick:()=>i(w=>[...w,void 0])}),a.jsx(T,{disabled:o||!t||!l.every(Boolean),label:"Clear",onClick:v,variant:"secondary"}),a.jsx(T,{disabled:o||!t||!l.every(Boolean),onClick:g}),!o&&s?a.jsx(z,{disabled:o,output:s}):a.jsx(m.Fragment,{}),!s&&y?y.map((w,k)=>a.jsx(z,{disabled:o,label:`Output - Sentence #${k+1}`,output:w})):a.jsx(m.Fragment,{})]})},qp="summarization",Jp=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await _c({inputs:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,setInput:n,variant:"textarea"}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?a.jsx(z,{disabled:r,output:u}):a.jsx(m.Fragment,{})]})},bp=async e=>{const t=await e.text();try{const n=JSON.parse(t);try{return JSON.stringify(n,void 0,2)}catch(r){if(r instanceof Error)return`Error during JSON.stringify: ${r.message}`}}catch(n){if(n instanceof Error)return`Error during JSON.parse: ${n.message}`}},em=e=>{const[t,n]=m.useState();return m.useEffect(()=>{e.input&&bp(e.input).then(n)},[e.input]),a.jsxs("div",{className:"w-full",children:[a.jsx("p",{className:"text-xl",children:e.label??"Input"}),e.input?a.jsx("pre",{className:"bg-yellow-200 break-words p-6 select-text w-full whitespace-pre-wrap",children:t}):a.jsxs("label",{className:"bg-yellow-200 block cursor-pointer py-6 text-center w-full",children:["No file chosen",a.jsx("input",{accept:".json",className:"hidden",onChange:r=>{r.target.files&&r.target.files[0]&&e.setInput(r.target.files[0])},type:"file"})]})]})},tm="table-question-answering",nm=e=>{const[t,n]=m.useState(),[r,l]=m.useState(),[i,o]=m.useState(!1),[u,s]=m.useState(),[c,y]=m.useState(),f=()=>{n(void 0),l(void 0),s(void 0),y(void 0)},v=async()=>{if(t&&r){o(!0);try{const g=await Nc({inputs:{query:t,table:JSON.parse(await r.text()??"{}")},model:e.model});y(g)}catch(g){g instanceof Error&&s(g)}finally{o(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,label:"Input - Query",setInput:n}),a.jsx(em,{input:r,label:"Input - Table",setInput:l}),a.jsx(T,{label:"Clear",disabled:i||!t,onClick:f,variant:"secondary"}),a.jsx(T,{disabled:i||!t,onClick:v}),!i&&u?a.jsx(z,{disabled:i,output:u}):a.jsx(m.Fragment,{}),!u&&c?a.jsx(z,{disabled:i,output:c}):a.jsx(m.Fragment,{})]})},rm="text-classification",lm=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await Oc({inputs:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?u.map(f=>a.jsx(z,{disabled:r,output:f},f.label)):a.jsx(m.Fragment,{})]})},im="text-generation",om=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await Tc({inputs:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?a.jsx(z,{disabled:r,output:u}):a.jsx(m.Fragment,{})]})},um=e=>a.jsxs("div",{className:"w-full",children:[a.jsx("p",{className:"text-xl",children:e.label??"Output"}),a.jsx("img",{className:`w-full ${e.disabled?"cursor-wait opacity-50":""}`,src:URL.createObjectURL(e.output)})]}),sm="text-to-image",am=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await Sc({inputs:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?a.jsx(um,{disabled:r,output:u}):a.jsx(m.Fragment,{})]})},cm="token-classification",fm=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await Pc({inputs:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?u.map(f=>a.jsx(z,{disabled:r,output:f},f.word)):a.jsx(m.Fragment,{})]})},dm="translation",pm=e=>{const[t,n]=m.useState(),[r,l]=m.useState(!1),[i,o]=m.useState(),[u,s]=m.useState(),c=()=>{n(void 0),o(void 0),s(void 0)},y=async()=>{if(t){l(!0);try{const f=await zc({inputs:t,model:e.model});s(f)}catch(f){f instanceof Error&&o(f)}finally{l(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,setInput:n}),a.jsx(T,{label:"Clear",disabled:r||!t,onClick:c,variant:"secondary"}),a.jsx(T,{disabled:r||!t,onClick:y}),!r&&i?a.jsx(z,{disabled:r,output:i}):a.jsx(m.Fragment,{}),!i&&u?a.jsx(z,{disabled:r,output:u}):a.jsx(m.Fragment,{})]})},mm="visual-question-answering",ym=e=>{const[t,n]=m.useState(),[r,l]=m.useState(),[i,o]=m.useState(!1),[u,s]=m.useState(),[c,y]=m.useState(),f=()=>{n(void 0),l(void 0),s(void 0),y(void 0)},v=async()=>{if(t&&r){o(!0);try{const g=await Rc({inputs:{question:t,image:r},model:e.model});y(g)}catch(g){g instanceof Error&&s(g)}finally{o(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,label:"Input - Question",setInput:n}),a.jsx(pn,{input:r,label:"Input - Image",setInput:l}),a.jsx(T,{label:"Clear",disabled:i||!r,onClick:f,variant:"secondary"}),a.jsx(T,{disabled:i||!r,onClick:v}),!i&&u?a.jsx(z,{disabled:i,output:u}):a.jsx(m.Fragment,{}),!u&&c?a.jsx(z,{disabled:i,output:c}):a.jsx(m.Fragment,{})]})},hm="zero-shot-classification",vm=e=>{const[t,n]=m.useState(),r=Array.from({length:2}).map(()=>{}),[l,i]=m.useState(r),[o,u]=m.useState(!1),[s,c]=m.useState(),[y,f]=m.useState(),v=()=>{n(void 0),i(r),c(void 0),f(void 0)},g=async()=>{if(t&&l.every(Boolean)){u(!0);try{const w=await Lc({inputs:t,model:e.model,parameters:{candidate_labels:l}});f(w)}catch(w){w instanceof Error&&c(w)}finally{u(!1)}}};return a.jsxs(m.Fragment,{children:[a.jsx(ee,{input:t,setInput:n}),l.map((w,k)=>a.jsx(ee,{input:w,label:`Parameter - Candidate Label #${k+1}`,setInput:M=>i(p=>[...p.slice(0,k),M,...p.slice(k+1,p.length)])})),a.jsx(T,{disabled:o||!t||!l.every(Boolean),label:"Add Candidate Label",onClick:()=>i(w=>[...w,void 0])}),a.jsx(T,{disabled:o||!t||!l.every(Boolean),label:"Clear",onClick:v,variant:"secondary"}),a.jsx(T,{disabled:o||!t||!l.every(Boolean),onClick:g}),!o&&s?a.jsx(z,{disabled:o,output:s}):a.jsx(m.Fragment,{}),!s&&y?y.map((w,k)=>a.jsx(z,{disabled:o,output:w})):a.jsx(m.Fragment,{})]})},gm=[Np,Tp,zp,Ip,Rp,Mp,$p,Vp,Qp,Wp,Yp,Gp,qp,tm,rm,im,sm,cm,dm,mm,hm],wm=e=>{if(!e.model||!e.task)return a.jsx(m.Fragment,{});switch(e.task){case"audio-classification":return a.jsx(Op,{model:e.model});case"automatic-speech-recognition":return a.jsx(Pp,{model:e.model});case"conversational":return a.jsx(Lp,{model:e.model});case"document-question-answering":return a.jsx(Fp,{model:e.model});case"feature-extraction":return a.jsx(Ap,{model:e.model});case"fill-mask":return a.jsx(Dp,{model:e.model});case"image-classification":return a.jsx(Up,{model:e.model});case"image-segmentation":return a.jsx(Bp,{model:e.model});case"image-to-text":return a.jsx(Hp,{model:e.model});case"object-detection":return a.jsx(Kp,{model:e.model});case"question-answering":return a.jsx(Xp,{model:e.model});case"sentence-similarity":return a.jsx(Zp,{model:e.model});case"summarization":return a.jsx(Jp,{model:e.model});case"table-question-answering":return a.jsx(nm,{model:e.model});case"text-classification":return a.jsx(lm,{model:e.model});case"text-generation":return a.jsx(om,{model:e.model});case"text-to-image":return a.jsx(am,{model:e.model});case"token-classification":return a.jsx(fm,{model:e.model});case"translation":return a.jsx(pm,{model:e.model});case"visual-question-answering":return a.jsx(ym,{model:e.model});case"zero-shot-classification":return a.jsx(vm,{model:e.model});default:return a.jsx(m.Fragment,{})}},Sm=e=>a.jsxs("div",{className:"w-full",children:[a.jsx("p",{className:"text-xl",children:"Task"}),a.jsxs("select",{className:"bg-yellow-200 cursor-pointer py-6 text-center w-full",onChange:t=>e.onTaskSelect(t.target.value),placeholder:"Select a task",value:e.task,children:[a.jsx("option",{children:"Select a task"}),gm.map(t=>a.jsx("option",{value:t,children:t},t))]})]}),Jl={},xm=async e=>{if(Jl[e])return Jl[e];const t=[];for await(const n of gp({search:{task:e}}))t.push(n);return t.sort((n,r)=>n.downloads>r.downloads?-1:n.downloads<r.downloads?1:n.likes>r.likes?-1:n.likes<r.likes?1:n.name>r.name?-1:n.name<r.name?1:0),Jl[e]=t,t},km=e=>{const[t,n]=m.useState(!1),[r,l]=m.useState([]);return m.useEffect(()=>{l([]),e.task&&(n(!0),xm(e.task).then(i=>l(i)).finally(()=>n(!1)))},[e.task]),r.length>0?a.jsxs("div",{className:"w-full",children:[a.jsx("p",{className:"text-xl",children:"Model"}),a.jsxs("select",{className:"bg-yellow-200 cursor-pointer py-6 text-center w-full",onChange:i=>e.onModelSelect(i.target.value),placeholder:"Select a model",value:e.model,children:[a.jsx("option",{children:"Select a model"}),r.map(i=>a.jsx("option",{value:i.name,children:i.name},i.name))]}),e.model?a.jsx("div",{className:"font-bold p-6 text-center text-yellow-200",children:a.jsx("a",{href:`https://huggingface.co/${e.model}`,rel:"noopener noferrer",target:"_blank",children:"🤗 View model on Hugging Face 🤗"})}):a.jsx(m.Fragment,{})]}):a.jsx("p",{className:"text-center w-full",children:e.task?t?"Loading models for this task":"No models available for this task":"Select a task to view available models"})},Em=()=>{const[e,t]=m.useState(),[n,r]=m.useState(),l=i=>{r(void 0),t(i)};return a.jsx("div",{className:"bg-yellow-500 flex flex-col h-full items-center min-h-screen min-w-screen overflow-auto w-full",children:a.jsxs("div",{className:"flex flex-col items-center justify-center py-24 space-y-12 w-2/3 lg:w-1/3",children:[a.jsx("header",{className:"text-center text-6xl",children:"🤗"}),a.jsx(Sm,{onTaskSelect:l,task:e}),a.jsx(km,{model:n,onModelSelect:r,task:e}),a.jsx(wm,{model:n,task:e})]})})};const Cm=()=>{const e="root",t=document.getElementById(e);if(t){const n=dc(t),r=a.jsx(m.StrictMode,{children:a.jsx(Em,{})});n.render(r)}};Cm();
diff --git a/spaces/mikeee/radiobee-aligner/tests/test_shuffle_sents.py b/spaces/mikeee/radiobee-aligner/tests/test_shuffle_sents.py
deleted file mode 100644
index 2c09d0253786f05946d007b64df43a30cd1fc032..0000000000000000000000000000000000000000
--- a/spaces/mikeee/radiobee-aligner/tests/test_shuffle_sents.py
+++ /dev/null
@@ -1,136 +0,0 @@
-"""Test shuffle_sents.
-
-    eps: float = 6
-    min_samples: int = 4
-    tf_type: str = "linear"
-    idf_type: Optional[str] = None
-    dl_type: Optional[str] = None
-    norm: Optional[str] = None
-    lang1: Optional[str] = "en"
-    lang2: Optional[str] = "zh"
-"""
-from radiobee.seg_text import seg_text
-from radiobee.shuffle_sents import shuffle_sents
-from radiobee.align_sents import align_sents
-
-text1 = """`Wretched inmates!' I ejaculated mentally, `you deserve perpetual isolation from your species for your churlish inhospitality. At least, I would not keep my doors barred in the day time. I don't care--I will get in!' So resolved, I grasped the latch and shook it vehemently. Vinegar-faced Joseph projected his head from a round window of the barn."""
-text2 = """“被囚禁的囚犯!”我在精神上被射精,“你应该永远与你的物种隔绝,因为你这种粗鲁的病态。至少,我白天不会锁门,我不在乎,我进去了!”我决心如此,我抓住了门锁,狠狠地摇了一下。醋脸的约瑟夫从谷仓的圆窗朝他的头照射。"""
-text3 = """"Elende Insassen! ejakulierte ich im Geiste, "ihr verdient die ewige Isolation von eurer Spezies für eure rüpelhafte Ungastlichkeit. Zumindest würde ich meine Türen tagsüber nicht verriegeln. Das ist mir egal - ich werde reinkommen!' So entschlossen, ergriff ich die Klinke und rüttelte heftig daran. Der essiggesichtige Joseph streckte seinen Kopf aus einem runden Fenster der Scheune."""
-
-
-def test_shuffle_sents_en_zh():
-    """Test shuffle_sents_en_zh."""
-    sents_en = seg_text(text1)
-    sents_zh = seg_text(text2)
-
-    lang1 = "en"
-    lang2 = "zh"
-
-    pairs = shuffle_sents(sents_en, sents_zh)
-    pairs_ = shuffle_sents(sents_en, sents_zh, lang1=lang1, lang2=lang2)
-
-    # pairs[3] == ('', "I don't care--I will get in!'", '')
-    assert pairs == pairs_
-
-    # assert not pairs[3][0]
-    # after swapping
-    assert not pairs[3][1]
-
-
-def test_shuffle_sents_en_de():
-    """Test shuffle_sents_en_de."""
-    sents_en = seg_text(text1)
-    sents_de = seg_text(text3)
-
-    lang1 = "en"
-    lang2 = "de"
-
-    pairs = shuffle_sents(sents_en, sents_de)
-    pairs_ = shuffle_sents(sents_en, sents_de, lang1=lang1, lang2=lang2)
-
-    assert pairs == pairs_
-
-    #
-    # assert not pairs[3][0]
-    _ = """In [218]: pairs[:2]
-    Out[218]:
-    [["`Wretched inmates!'", '', ''],
-     ['I ejaculated mentally, `you deserve perpetual isolation from your species for your churlish inhospitality.',
-      '"Elende Insassen! ejakulierte ich im Geiste, "ihr verdient die ewige Isolation von eurer Spezies für eure rüpelhafte Ungastlichkeit.',
-      0.62]]
-    """
-    assert not pairs[0][1]
-    assert "mentally" in str(pairs[1]) and "Elende" in str(pairs[1])
-
-    # [elm[2] for elm in pairs]
-    # ['', 0.62, 0.72, 0.74, 0.68, 0.79]
-    if isinstance(pairs[1][2], float):
-        assert pairs[1][2] > 0.6
-    if isinstance(pairs[2][2], float):
-        assert pairs[2][2] > 0.7
-    if isinstance(pairs[3][2], float):
-        assert pairs[3][2] > 0.7
-    if isinstance(pairs[4][2], float):
-        assert pairs[4][2] > 0.6
-    if isinstance(pairs[5][2], float):
-        assert pairs[5][2] > 0.7
-
-
-_ = """
-In [232]: shuffle_sents.cmat.round(2)
-Out[232]:
-array([[ 0.27,  0.62,  0.07,  0.11,  0.02,  0.02],
-       [ 0.03,  0.09,  0.72,  0.18,  0.07, -0.07],
-       [ 0.19,  0.07,  0.16,  0.74, -0.01, -0.02],
-       [-0.02,  0.18,  0.16,  0.06,  0.68, -0.04],
-       [ 0.02,  0.07,  0.04, -0.04,  0.02,  0.79]], dtype=float32)
-pairs[1]
-sents_en[1], sents_de[0], shuffle_sents.cmat[0, 1]
-['I ejaculated mentally, `you deserve perpetual isolation from your species for your churlish inhospitality.',
- '"Elende Insassen! ejakulierte ich im Geiste, "ihr verdient die ewige Isolation von eurer Spezies für eure rüpelhafte Ungastlichkeit.',
- 0.62]
-
-pairs[2]
-sents_en[2], sents_de[1], shuffle_sents.cmat[1, 2].round(2)
-Out[244]:
-('At least, I would not keep my doors barred in the day time.',
- 'Zumindest würde ich meine Türen tagsüber nicht verriegeln.',
- 0.72)
-...
-
-import mtplotlib
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-sns.set()
-set_style("darkgrind")
-plt.ion()
-
-ali = shuffle_sents(sents_en, sents_de)
-sns.heatmap(shuffle_sents.cmat, cmap="viridis_r").invert_yaxis()
-ax = plt.gca()
-ax.set_xlabel(shuffle_sents.lang1)
-ax.set_ylabel(shuffle_sents.lang2)
-
-ali == [["`Wretched inmates!'", '', ''],
- ['I ejaculated mentally, `you deserve perpetual isolation from your species for your churlish inhospitality.',
-  '"Elende Insassen! ejakulierte ich im Geiste, "ihr verdient die ewige Isolation von eurer Spezies für eure rüpelhafte Ungastlichkeit.',
-  0.62],
- ['At least, I would not keep my doors barred in the day time.',
-  'Zumindest würde ich meine Türen tagsüber nicht verriegeln.',
-  0.72],
- ["I don't care--I will get in!'",
-  "Das ist mir egal - ich werde reinkommen!'",
-  0.74],
- ['So resolved, I grasped the latch and shook it vehemently.',
-  'So entschlossen, ergriff ich die Klinke und rüttelte heftig daran.',
-  0.68],
- ['Vinegar-faced Joseph projected his head from a round window of the barn.',
-  'Der essiggesichtige Joseph streckte seinen Kopf aus einem runden Fenster der Scheune.',
-  0.79]]
-
-res1 = align_sents(sents_en, sents_de)
-ali = shuffle_sents(sents_en, sents_de)
-for idx in range(1, 6):
-    assert res1[idx] == tuple(ali[idx][:2])
-"""
diff --git a/spaces/mmecheri/Rakuten_Streamlit/page_descriptions/conclusion_txt.md b/spaces/mmecheri/Rakuten_Streamlit/page_descriptions/conclusion_txt.md
deleted file mode 100644
index 207687efa692294f914201109f091e6fb94bff1b..0000000000000000000000000000000000000000
--- a/spaces/mmecheri/Rakuten_Streamlit/page_descriptions/conclusion_txt.md
+++ /dev/null
@@ -1,11 +0,0 @@
->- En appliquant la méthode de Vote, nous avons obtenu des performances supérieures à celles des modèles pris séparément
->- L’**objectif a été atteint** et les résultats dépassent ceux du modèle de référence Rakuten
-
-
-
-Et pour finir, voici quelques pistes qui pourraient permettre d'améliorer nos résulats :
->- Préprocessing des images qui présentent un fond blanc important, comme par exemple,  remplacer les bords blancs par du noir, effectuer des zooms, ...
->- Améliorer et enrichir la partie augmentation des données Images en applicant d’autres transformations,  comme par exemple, la luminosité et le contraste, recadrage(cropping), modifier les couleurs,...
->- Gérer le déséquilibre de notre jeu de données 
->- Réaliser d'autres combinaisons pour le système de Vote, implémenter d’autres approches d’ensembling telle que le concaténation de deux modèles Texte et Image
-
diff --git a/spaces/mrmocciai/rvc-genshin-v2/vc_infer_pipeline.py b/spaces/mrmocciai/rvc-genshin-v2/vc_infer_pipeline.py
deleted file mode 100644
index 82c15f59a8072e1b317fa1d750ccc1b814a6989d..0000000000000000000000000000000000000000
--- a/spaces/mrmocciai/rvc-genshin-v2/vc_infer_pipeline.py
+++ /dev/null
@@ -1,443 +0,0 @@
-import numpy as np, parselmouth, torch, pdb, sys, os
-from time import time as ttime
-import torch.nn.functional as F
-import scipy.signal as signal
-import pyworld, os, traceback, faiss, librosa, torchcrepe
-from scipy import signal
-from functools import lru_cache
-
-now_dir = os.getcwd()
-sys.path.append(now_dir)
-
-bh, ah = signal.butter(N=5, Wn=48, btype="high", fs=16000)
-
-input_audio_path2wav = {}
-
-
-@lru_cache
-def cache_harvest_f0(input_audio_path, fs, f0max, f0min, frame_period):
-    audio = input_audio_path2wav[input_audio_path]
-    f0, t = pyworld.harvest(
-        audio,
-        fs=fs,
-        f0_ceil=f0max,
-        f0_floor=f0min,
-        frame_period=frame_period,
-    )
-    f0 = pyworld.stonemask(audio, f0, t, fs)
-    return f0
-
-
-def change_rms(data1, sr1, data2, sr2, rate):  # 1是输入音频，2是输出音频,rate是2的占比
-    # print(data1.max(),data2.max())
-    rms1 = librosa.feature.rms(
-        y=data1, frame_length=sr1 // 2 * 2, hop_length=sr1 // 2
-    )  # 每半秒一个点
-    rms2 = librosa.feature.rms(y=data2, frame_length=sr2 // 2 * 2, hop_length=sr2 // 2)
-    rms1 = torch.from_numpy(rms1)
-    rms1 = F.interpolate(
-        rms1.unsqueeze(0), size=data2.shape[0], mode="linear"
-    ).squeeze()
-    rms2 = torch.from_numpy(rms2)
-    rms2 = F.interpolate(
-        rms2.unsqueeze(0), size=data2.shape[0], mode="linear"
-    ).squeeze()
-    rms2 = torch.max(rms2, torch.zeros_like(rms2) + 1e-6)
-    data2 *= (
-        torch.pow(rms1, torch.tensor(1 - rate))
-        * torch.pow(rms2, torch.tensor(rate - 1))
-    ).numpy()
-    return data2
-
-
-class VC(object):
-    def __init__(self, tgt_sr, config):
-        self.x_pad, self.x_query, self.x_center, self.x_max, self.is_half = (
-            config.x_pad,
-            config.x_query,
-            config.x_center,
-            config.x_max,
-            config.is_half,
-        )
-        self.sr = 16000  # hubert输入采样率
-        self.window = 160  # 每帧点数
-        self.t_pad = self.sr * self.x_pad  # 每条前后pad时间
-        self.t_pad_tgt = tgt_sr * self.x_pad
-        self.t_pad2 = self.t_pad * 2
-        self.t_query = self.sr * self.x_query  # 查询切点前后查询时间
-        self.t_center = self.sr * self.x_center  # 查询切点位置
-        self.t_max = self.sr * self.x_max  # 免查询时长阈值
-        self.device = config.device
-
-    def get_f0(
-        self,
-        input_audio_path,
-        x,
-        p_len,
-        f0_up_key,
-        f0_method,
-        filter_radius,
-        inp_f0=None,
-    ):
-        global input_audio_path2wav
-        time_step = self.window / self.sr * 1000
-        f0_min = 50
-        f0_max = 1100
-        f0_mel_min = 1127 * np.log(1 + f0_min / 700)
-        f0_mel_max = 1127 * np.log(1 + f0_max / 700)
-        if f0_method == "pm":
-            f0 = (
-                parselmouth.Sound(x, self.sr)
-                .to_pitch_ac(
-                    time_step=time_step / 1000,
-                    voicing_threshold=0.6,
-                    pitch_floor=f0_min,
-                    pitch_ceiling=f0_max,
-                )
-                .selected_array["frequency"]
-            )
-            pad_size = (p_len - len(f0) + 1) // 2
-            if pad_size > 0 or p_len - len(f0) - pad_size > 0:
-                f0 = np.pad(
-                    f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant"
-                )
-        elif f0_method == "harvest":
-            input_audio_path2wav[input_audio_path] = x.astype(np.double)
-            f0 = cache_harvest_f0(input_audio_path, self.sr, f0_max, f0_min, 10)
-            if filter_radius > 2:
-                f0 = signal.medfilt(f0, 3)
-        elif f0_method == "crepe":
-            model = "full"
-            # Pick a batch size that doesn't cause memory errors on your gpu
-            batch_size = 512
-            # Compute pitch using first gpu
-            audio = torch.tensor(np.copy(x))[None].float()
-            f0, pd = torchcrepe.predict(
-                audio,
-                self.sr,
-                self.window,
-                f0_min,
-                f0_max,
-                model,
-                batch_size=batch_size,
-                device=self.device,
-                return_periodicity=True,
-            )
-            pd = torchcrepe.filter.median(pd, 3)
-            f0 = torchcrepe.filter.mean(f0, 3)
-            f0[pd < 0.1] = 0
-            f0 = f0[0].cpu().numpy()
-        elif f0_method == "rmvpe":
-            if hasattr(self, "model_rmvpe") == False:
-                from rmvpe import RMVPE
-
-                print("loading rmvpe model")
-                self.model_rmvpe = RMVPE(
-                    "rmvpe.pt", is_half=self.is_half, device=self.device
-                )
-            f0 = self.model_rmvpe.infer_from_audio(x, thred=0.03)
-        f0 *= pow(2, f0_up_key / 12)
-        # with open("test.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
-        tf0 = self.sr // self.window  # 每秒f0点数
-        if inp_f0 is not None:
-            delta_t = np.round(
-                (inp_f0[:, 0].max() - inp_f0[:, 0].min()) * tf0 + 1
-            ).astype("int16")
-            replace_f0 = np.interp(
-                list(range(delta_t)), inp_f0[:, 0] * 100, inp_f0[:, 1]
-            )
-            shape = f0[self.x_pad * tf0 : self.x_pad * tf0 + len(replace_f0)].shape[0]
-            f0[self.x_pad * tf0 : self.x_pad * tf0 + len(replace_f0)] = replace_f0[
-                :shape
-            ]
-        # with open("test_opt.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
-        f0bak = f0.copy()
-        f0_mel = 1127 * np.log(1 + f0 / 700)
-        f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (
-            f0_mel_max - f0_mel_min
-        ) + 1
-        f0_mel[f0_mel <= 1] = 1
-        f0_mel[f0_mel > 255] = 255
-        f0_coarse = np.rint(f0_mel).astype(np.int)
-        return f0_coarse, f0bak  # 1-0
-
-    def vc(
-        self,
-        model,
-        net_g,
-        sid,
-        audio0,
-        pitch,
-        pitchf,
-        times,
-        index,
-        big_npy,
-        index_rate,
-        version,
-        protect,
-    ):  # ,file_index,file_big_npy
-        feats = torch.from_numpy(audio0)
-        if self.is_half:
-            feats = feats.half()
-        else:
-            feats = feats.float()
-        if feats.dim() == 2:  # double channels
-            feats = feats.mean(-1)
-        assert feats.dim() == 1, feats.dim()
-        feats = feats.view(1, -1)
-        padding_mask = torch.BoolTensor(feats.shape).to(self.device).fill_(False)
-
-        inputs = {
-            "source": feats.to(self.device),
-            "padding_mask": padding_mask,
-            "output_layer": 9 if version == "v1" else 12,
-        }
-        t0 = ttime()
-        with torch.no_grad():
-            logits = model.extract_features(**inputs)
-            feats = model.final_proj(logits[0]) if version == "v1" else logits[0]
-        if protect < 0.5 and pitch != None and pitchf != None:
-            feats0 = feats.clone()
-        if (
-            isinstance(index, type(None)) == False
-            and isinstance(big_npy, type(None)) == False
-            and index_rate != 0
-        ):
-            npy = feats[0].cpu().numpy()
-            if self.is_half:
-                npy = npy.astype("float32")
-
-            # _, I = index.search(npy, 1)
-            # npy = big_npy[I.squeeze()]
-
-            score, ix = index.search(npy, k=8)
-            weight = np.square(1 / score)
-            weight /= weight.sum(axis=1, keepdims=True)
-            npy = np.sum(big_npy[ix] * np.expand_dims(weight, axis=2), axis=1)
-
-            if self.is_half:
-                npy = npy.astype("float16")
-            feats = (
-                torch.from_numpy(npy).unsqueeze(0).to(self.device) * index_rate
-                + (1 - index_rate) * feats
-            )
-
-        feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
-        if protect < 0.5 and pitch != None and pitchf != None:
-            feats0 = F.interpolate(feats0.permute(0, 2, 1), scale_factor=2).permute(
-                0, 2, 1
-            )
-        t1 = ttime()
-        p_len = audio0.shape[0] // self.window
-        if feats.shape[1] < p_len:
-            p_len = feats.shape[1]
-            if pitch != None and pitchf != None:
-                pitch = pitch[:, :p_len]
-                pitchf = pitchf[:, :p_len]
-
-        if protect < 0.5 and pitch != None and pitchf != None:
-            pitchff = pitchf.clone()
-            pitchff[pitchf > 0] = 1
-            pitchff[pitchf < 1] = protect
-            pitchff = pitchff.unsqueeze(-1)
-            feats = feats * pitchff + feats0 * (1 - pitchff)
-            feats = feats.to(feats0.dtype)
-        p_len = torch.tensor([p_len], device=self.device).long()
-        with torch.no_grad():
-            if pitch != None and pitchf != None:
-                audio1 = (
-                    (net_g.infer(feats, p_len, pitch, pitchf, sid)[0][0, 0])
-                    .data.cpu()
-                    .float()
-                    .numpy()
-                )
-            else:
-                audio1 = (
-                    (net_g.infer(feats, p_len, sid)[0][0, 0]).data.cpu().float().numpy()
-                )
-        del feats, p_len, padding_mask
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-        t2 = ttime()
-        times[0] += t1 - t0
-        times[2] += t2 - t1
-        return audio1
-
-    def pipeline(
-        self,
-        model,
-        net_g,
-        sid,
-        audio,
-        input_audio_path,
-        times,
-        f0_up_key,
-        f0_method,
-        file_index,
-        # file_big_npy,
-        index_rate,
-        if_f0,
-        filter_radius,
-        tgt_sr,
-        resample_sr,
-        rms_mix_rate,
-        version,
-        protect,
-        f0_file=None,
-    ):
-        if (
-            file_index != ""
-            # and file_big_npy != ""
-            # and os.path.exists(file_big_npy) == True
-            and os.path.exists(file_index) == True
-            and index_rate != 0
-        ):
-            try:
-                index = faiss.read_index(file_index)
-                # big_npy = np.load(file_big_npy)
-                big_npy = index.reconstruct_n(0, index.ntotal)
-            except:
-                traceback.print_exc()
-                index = big_npy = None
-        else:
-            index = big_npy = None
-        audio = signal.filtfilt(bh, ah, audio)
-        audio_pad = np.pad(audio, (self.window // 2, self.window // 2), mode="reflect")
-        opt_ts = []
-        if audio_pad.shape[0] > self.t_max:
-            audio_sum = np.zeros_like(audio)
-            for i in range(self.window):
-                audio_sum += audio_pad[i : i - self.window]
-            for t in range(self.t_center, audio.shape[0], self.t_center):
-                opt_ts.append(
-                    t
-                    - self.t_query
-                    + np.where(
-                        np.abs(audio_sum[t - self.t_query : t + self.t_query])
-                        == np.abs(audio_sum[t - self.t_query : t + self.t_query]).min()
-                    )[0][0]
-                )
-        s = 0
-        audio_opt = []
-        t = None
-        t1 = ttime()
-        audio_pad = np.pad(audio, (self.t_pad, self.t_pad), mode="reflect")
-        p_len = audio_pad.shape[0] // self.window
-        inp_f0 = None
-        if hasattr(f0_file, "name") == True:
-            try:
-                with open(f0_file.name, "r") as f:
-                    lines = f.read().strip("\n").split("\n")
-                inp_f0 = []
-                for line in lines:
-                    inp_f0.append([float(i) for i in line.split(",")])
-                inp_f0 = np.array(inp_f0, dtype="float32")
-            except:
-                traceback.print_exc()
-        sid = torch.tensor(sid, device=self.device).unsqueeze(0).long()
-        pitch, pitchf = None, None
-        if if_f0 == 1:
-            pitch, pitchf = self.get_f0(
-                input_audio_path,
-                audio_pad,
-                p_len,
-                f0_up_key,
-                f0_method,
-                filter_radius,
-                inp_f0,
-            )
-            pitch = pitch[:p_len]
-            pitchf = pitchf[:p_len]
-            if self.device == "mps":
-                pitchf = pitchf.astype(np.float32)
-            pitch = torch.tensor(pitch, device=self.device).unsqueeze(0).long()
-            pitchf = torch.tensor(pitchf, device=self.device).unsqueeze(0).float()
-        t2 = ttime()
-        times[1] += t2 - t1
-        for t in opt_ts:
-            t = t // self.window * self.window
-            if if_f0 == 1:
-                audio_opt.append(
-                    self.vc(
-                        model,
-                        net_g,
-                        sid,
-                        audio_pad[s : t + self.t_pad2 + self.window],
-                        pitch[:, s // self.window : (t + self.t_pad2) // self.window],
-                        pitchf[:, s // self.window : (t + self.t_pad2) // self.window],
-                        times,
-                        index,
-                        big_npy,
-                        index_rate,
-                        version,
-                        protect,
-                    )[self.t_pad_tgt : -self.t_pad_tgt]
-                )
-            else:
-                audio_opt.append(
-                    self.vc(
-                        model,
-                        net_g,
-                        sid,
-                        audio_pad[s : t + self.t_pad2 + self.window],
-                        None,
-                        None,
-                        times,
-                        index,
-                        big_npy,
-                        index_rate,
-                        version,
-                        protect,
-                    )[self.t_pad_tgt : -self.t_pad_tgt]
-                )
-            s = t
-        if if_f0 == 1:
-            audio_opt.append(
-                self.vc(
-                    model,
-                    net_g,
-                    sid,
-                    audio_pad[t:],
-                    pitch[:, t // self.window :] if t is not None else pitch,
-                    pitchf[:, t // self.window :] if t is not None else pitchf,
-                    times,
-                    index,
-                    big_npy,
-                    index_rate,
-                    version,
-                    protect,
-                )[self.t_pad_tgt : -self.t_pad_tgt]
-            )
-        else:
-            audio_opt.append(
-                self.vc(
-                    model,
-                    net_g,
-                    sid,
-                    audio_pad[t:],
-                    None,
-                    None,
-                    times,
-                    index,
-                    big_npy,
-                    index_rate,
-                    version,
-                    protect,
-                )[self.t_pad_tgt : -self.t_pad_tgt]
-            )
-        audio_opt = np.concatenate(audio_opt)
-        if rms_mix_rate != 1:
-            audio_opt = change_rms(audio, 16000, audio_opt, tgt_sr, rms_mix_rate)
-        if resample_sr >= 16000 and tgt_sr != resample_sr:
-            audio_opt = librosa.resample(
-                audio_opt, orig_sr=tgt_sr, target_sr=resample_sr
-            )
-        audio_max = np.abs(audio_opt).max() / 0.99
-        max_int16 = 32768
-        if audio_max > 1:
-            max_int16 /= audio_max
-        audio_opt = (audio_opt * max_int16).astype(np.int16)
-        del pitch, pitchf, sid
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-        return audio_opt
diff --git a/spaces/mshukor/UnIVAL/fairseq/examples/camembert/README.md b/spaces/mshukor/UnIVAL/fairseq/examples/camembert/README.md
deleted file mode 100644
index 5ef4fe3f151bb468712f3be935ea5bb1b1360bf7..0000000000000000000000000000000000000000
--- a/spaces/mshukor/UnIVAL/fairseq/examples/camembert/README.md
+++ /dev/null
@@ -1,75 +0,0 @@
-# CamemBERT: a Tasty French Language Model
-
-## Introduction
-
-[CamemBERT](https://arxiv.org/abs/1911.03894) is a pretrained language model trained on 138GB of French text based on RoBERTa.
-
-Also available in [github.com/huggingface/transformers](https://github.com/huggingface/transformers/).
-
-## Pre-trained models
-
-| Model                          | #params | Download                                                                                                                 | Arch. | Training data                     |
-|--------------------------------|---------|--------------------------------------------------------------------------------------------------------------------------|-------|-----------------------------------|
-| `camembert` / `camembert-base` | 110M    | [camembert-base.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-base.tar.gz)                             | Base  | OSCAR (138 GB of text)            |
-| `camembert-large`              | 335M    | [camembert-large.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-large.tar.gz)                           | Large | CCNet (135 GB of text)            |
-| `camembert-base-ccnet`         | 110M    | [camembert-base-ccnet.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-base-ccnet.tar.gz)                 | Base  | CCNet (135 GB of text)            |
-| `camembert-base-wikipedia-4gb` | 110M    | [camembert-base-wikipedia-4gb.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-base-wikipedia-4gb.tar.gz) | Base  | Wikipedia (4 GB of text)          |
-| `camembert-base-oscar-4gb`     | 110M    | [camembert-base-oscar-4gb.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-base-oscar-4gb.tar.gz)         | Base  | Subsample of OSCAR (4 GB of text) |
-| `camembert-base-ccnet-4gb`     | 110M    | [camembert-base-ccnet-4gb.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-base-ccnet-4gb.tar.gz)         | Base  | Subsample of CCNet (4 GB of text) |
-
-## Example usage
-
-### fairseq
-##### Load CamemBERT from torch.hub (PyTorch >= 1.1):
-```python
-import torch
-camembert = torch.hub.load('pytorch/fairseq', 'camembert')
-camembert.eval()  # disable dropout (or leave in train mode to finetune)
-```
-
-##### Load CamemBERT (for PyTorch 1.0 or custom models):
-```python
-# Download camembert model
-wget https://dl.fbaipublicfiles.com/fairseq/models/camembert-base.tar.gz
-tar -xzvf camembert.tar.gz
-
-# Load the model in fairseq
-from fairseq.models.roberta import CamembertModel
-camembert = CamembertModel.from_pretrained('/path/to/camembert')
-camembert.eval()  # disable dropout (or leave in train mode to finetune)
-```
-
-##### Filling masks:
-```python
-masked_line = 'Le camembert est <mask> :)'
-camembert.fill_mask(masked_line, topk=3)
-# [('Le camembert est délicieux :)', 0.4909118115901947, ' délicieux'),
-#  ('Le camembert est excellent :)', 0.10556942224502563, ' excellent'),
-#  ('Le camembert est succulent :)', 0.03453322499990463, ' succulent')]
-```
-
-##### Extract features from Camembert:
-```python
-# Extract the last layer's features
-line = "J'aime le camembert !"
-tokens = camembert.encode(line)
-last_layer_features = camembert.extract_features(tokens)
-assert last_layer_features.size() == torch.Size([1, 10, 768])
-
-# Extract all layer's features (layer 0 is the embedding layer)
-all_layers = camembert.extract_features(tokens, return_all_hiddens=True)
-assert len(all_layers) == 13
-assert torch.all(all_layers[-1] == last_layer_features)
-```
-
-## Citation
-If you use our work, please cite:
-
-```bibtex
-@inproceedings{martin2020camembert,
-  title={CamemBERT: a Tasty French Language Model},
-  author={Martin, Louis and Muller, Benjamin and Su{\'a}rez, Pedro Javier Ortiz and Dupont, Yoann and Romary, Laurent and de la Clergerie, {\'E}ric Villemonte and Seddah, Djam{\'e} and Sagot, Beno{\^\i}t},
-  booktitle={Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics},
-  year={2020}
-}
-```
diff --git a/spaces/mshukor/UnIVAL/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/train_subset_lgbeam.sh b/spaces/mshukor/UnIVAL/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/train_subset_lgbeam.sh
deleted file mode 100644
index 913c1d8e4357c146026b86e78f0b16f921776441..0000000000000000000000000000000000000000
--- a/spaces/mshukor/UnIVAL/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/train_subset_lgbeam.sh
+++ /dev/null
@@ -1,129 +0,0 @@
-#!/usr/bin/env bash
-
-out_root=/tmp
-out_name=train_${RANDOM}
-num_nonsil_states=1
-
-valid="dev_other"
-train="train"
-mono_size="-1"  # 2000
-tri1_size="-1"  # 5000
-tri2b_size="-1"  # 10000
-tri3b_size="-1"  # 10000
-
-# Acoustic model parameters
-numLeavesTri1=2000
-numGaussTri1=10000
-numLeavesMLLT=2500
-numGaussMLLT=15000
-numLeavesSAT=2500
-numGaussSAT=15000
-
-stage=1
-max_stage=1
-
-. ./cmd.sh
-. ./path.sh
-. parse_options.sh
-
-data=$1
-lang=$2
-lang_test=$3
-
-exp_root=$out_root/$out_name
-
-# you might not want to do this for interactive shells.
-set -e
-
-
-if [ $stage -le 1 ] && [ $max_stage -ge 1 ]; then
-  # train a monophone system
-  if [ ! $mono_size -eq -1 ]; then
-    utils/subset_data_dir.sh $data/$train $mono_size $data/${train}_${mono_size}
-    mono_train=${train}_${mono_size}
-  else
-    mono_train=${train}
-  fi
-
-  steps/train_mono.sh --boost-silence 1.25 --nj 20 --cmd "$train_cmd" \
-    --initial-beam 40 --regular-beam 60 --retry-beam 120 \
-    $data/$mono_train $lang $exp_root/mono
-
-  utils/mkgraph.sh $lang_test $exp_root/mono $exp_root/mono/graph
-  steps/decode.sh --nj 20 --cmd "$decode_cmd" \
-    $exp_root/mono/graph $data/$valid $exp_root/mono/decode_$valid &
-fi
-
-
-if [ $stage -le 2 ] && [ $max_stage -ge 2 ]; then
-  # train a first delta + delta-delta triphone system on a subset of 5000 utterances
-  if [ ! $tri1_size -eq -1 ]; then
-    utils/subset_data_dir.sh $data/$train $tri1_size $data/${train}_${tri1_size}
-    tri1_train=${train}_${tri1_size}
-  else
-    tri1_train=${train}
-  fi
-
-  steps/align_si.sh --boost-silence 1.25 --nj 10 --cmd "$train_cmd" \
-    $data/$tri1_train $lang \
-    $exp_root/mono $exp_root/mono_ali_${tri1_train}
-
-  steps_gan/train_deltas.sh --boost-silence 1.25 --cmd "$train_cmd" \
-      --num_nonsil_states $num_nonsil_states $numLeavesTri1 $numGaussTri1 \
-      $data/$tri1_train $lang \
-      $exp_root/mono_ali_${tri1_train} $exp_root/tri1
-
-  utils/mkgraph.sh $lang_test $exp_root/tri1 $exp_root/tri1/graph
-  steps/decode.sh --nj 20 --cmd "$decode_cmd" \
-    $exp_root/tri1/graph $data/$valid $exp_root/tri1/decode_$valid &
-fi
-
-if [ $stage -le 3 ] && [ $max_stage -ge 3 ]; then
-  # train an LDA+MLLT system.
-  if [ ! $tri2b_size -eq -1 ]; then
-    utils/subset_data_dir.sh $data/$train $tri2b_size $data/${train}_${tri2b_size}
-    tri2b_train=${train}_${tri2b_size}
-  else
-    tri2b_train=${train}
-  fi
-
-  steps/align_si.sh --nj 10 --cmd "$train_cmd" \
-    $data/$tri2b_train $lang \
-    $exp_root/tri1 $exp_root/tri1_ali_${tri2b_train}
-
-  steps_gan/train_lda_mllt.sh --cmd "$train_cmd" \
-      --num_nonsil_states $num_nonsil_states \
-      --splice-opts "--left-context=3 --right-context=3" $numLeavesMLLT $numGaussMLLT \
-      $data/$tri2b_train $lang \
-      $exp_root/tri1_ali_${tri2b_train} $exp_root/tri2b
-
-  utils/mkgraph.sh $lang_test $exp_root/tri2b $exp_root/tri2b/graph
-  steps/decode.sh --nj 20 --cmd "$decode_cmd" \
-    $exp_root/tri2b/graph $data/$valid $exp_root/tri2b/decode_$valid &
-fi
-
-
-if [ $stage -le 4 ] && [ $max_stage -ge 4 ]; then
-  # Train tri3b, which is LDA+MLLT+SAT on 10k utts
-  if [ ! $tri3b_size -eq -1 ]; then
-    utils/subset_data_dir.sh $data/$train $tri3b_size $data/${train}_${tri3b_size}
-    tri3b_train=${train}_${tri3b_size}
-  else
-    tri3b_train=${train}
-  fi
-
-  steps/align_si.sh  --nj 10 --cmd "$train_cmd" --use-graphs true \
-    $data/$tri3b_train $lang \
-    $exp_root/tri2b $exp_root/tri2b_ali_${tri2b_train}
-
-  steps_gan/train_sat.sh --cmd "$train_cmd" \
-    --num_nonsil_states $num_nonsil_states $numLeavesSAT $numGaussSAT \
-    $data/$tri3b_train $lang \
-    $exp_root/tri2b_ali_${tri2b_train} $exp_root/tri3b
-
-  utils/mkgraph.sh $lang_test $exp_root/tri3b $exp_root/tri3b/graph
-  steps/decode_fmllr.sh --nj 20 --cmd "$decode_cmd" \
-    $exp_root/tri3b/graph $data/$valid $exp_root/tri3b/decode_$valid &
-fi
-
-wait
diff --git a/spaces/mshukor/UnIVAL/fairseq/fairseq/optim/adamax.py b/spaces/mshukor/UnIVAL/fairseq/fairseq/optim/adamax.py
deleted file mode 100644
index 98ff8ad7ad6c12ab5efc53ca76db2f1663be7906..0000000000000000000000000000000000000000
--- a/spaces/mshukor/UnIVAL/fairseq/fairseq/optim/adamax.py
+++ /dev/null
@@ -1,172 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import torch
-import torch.optim
-
-from . import LegacyFairseqOptimizer, register_optimizer
-
-
-@register_optimizer("adamax")
-class FairseqAdamax(LegacyFairseqOptimizer):
-    def __init__(self, args, params):
-        super().__init__(args)
-        self._optimizer = Adamax(params, **self.optimizer_config)
-
-    @staticmethod
-    def add_args(parser):
-        """Add optimizer-specific arguments to the parser."""
-        # fmt: off
-        parser.add_argument('--adamax-betas', default='(0.9, 0.999)', metavar='B',
-                            help='betas for Adam optimizer')
-        parser.add_argument('--adamax-eps', type=float, default=1e-8, metavar='D',
-                            help='epsilon for Adam optimizer')
-        parser.add_argument('--weight-decay', '--wd', default=0.0, type=float, metavar='WD',
-                            help='weight decay')
-        parser.add_argument('--no-bias-correction', default=False, action='store_true',
-                            help='disable bias correction')
-        # fmt: on
-
-    @property
-    def optimizer_config(self):
-        """
-        Return a kwarg dictionary that will be used to override optimizer
-        args stored in checkpoints. This allows us to load a checkpoint and
-        resume training using a different set of optimizer args, e.g., with a
-        different learning rate.
-        """
-        return {
-            "lr": self.args.lr[0],
-            "betas": eval(self.args.adamax_betas),
-            "eps": self.args.adamax_eps,
-            "weight_decay": self.args.weight_decay,
-            "bias_correction": not self.args.no_bias_correction,
-        }
-
-
-class Adamax(torch.optim.Optimizer):
-    """Implements Adamax algorithm (a variant of Adam based on infinity norm).
-
-    It has been proposed in `Adam: A Method for Stochastic Optimization`__.
-
-    Compared to the version in PyTorch, this version implements a fix for weight decay.
-
-    Args:
-        params (iterable): iterable of parameters to optimize or dicts defining
-            parameter groups
-        lr (float, optional): learning rate (default: 2e-3)
-        betas (Tuple[float, float], optional): coefficients used for computing
-            running averages of gradient and its square
-        eps (float, optional): term added to the denominator to improve
-            numerical stability (default: 1e-8)
-        weight_decay (float, optional): weight decay (L2 penalty) (default: 0)
-        bias_correction (bool, optional): enable bias correction (default: True)
-
-    __ https://arxiv.org/abs/1412.6980
-    """
-
-    def __init__(
-        self,
-        params,
-        lr=2e-3,
-        betas=(0.9, 0.999),
-        eps=1e-8,
-        weight_decay=0,
-        bias_correction=True,
-    ):
-        if not 0.0 <= lr:
-            raise ValueError("Invalid learning rate: {}".format(lr))
-        if not 0.0 <= eps:
-            raise ValueError("Invalid epsilon value: {}".format(eps))
-        if not 0.0 <= betas[0] < 1.0:
-            raise ValueError("Invalid beta parameter at index 0: {}".format(betas[0]))
-        if not 0.0 <= betas[1] < 1.0:
-            raise ValueError("Invalid beta parameter at index 1: {}".format(betas[1]))
-        if not 0.0 <= weight_decay:
-            raise ValueError("Invalid weight_decay value: {}".format(weight_decay))
-
-        defaults = dict(
-            lr=lr,
-            betas=betas,
-            eps=eps,
-            weight_decay=weight_decay,
-            bias_correction=bias_correction,
-        )
-        super(Adamax, self).__init__(params, defaults)
-
-    @property
-    def supports_memory_efficient_fp16(self):
-        return True
-
-    @property
-    def supports_flat_params(self):
-        return True
-
-    def step(self, closure=None):
-        """Performs a single optimization step.
-
-        Args:
-            closure (callable, optional): A closure that reevaluates the model
-                and returns the loss.
-        """
-        loss = None
-        if closure is not None:
-            loss = closure()
-
-        for group in self.param_groups:
-            for p in group["params"]:
-                if p.grad is None:
-                    continue
-                grad = p.grad.data.float()
-                if grad.is_sparse:
-                    raise RuntimeError("Adamax does not support sparse gradients")
-
-                p_data_fp32 = p.data
-                if p.data.dtype in {torch.float16, torch.bfloat16}:
-                    p_data_fp32 = p_data_fp32.float()
-
-                state = self.state[p]
-
-                # State initialization
-                if len(state) == 0:
-                    state["step"] = 0
-                    state["exp_avg"] = torch.zeros_like(p_data_fp32)
-                    state["exp_inf"] = torch.zeros_like(p_data_fp32)
-                else:
-                    state["exp_avg"] = state["exp_avg"].to(p_data_fp32)
-                    state["exp_inf"] = state["exp_inf"].to(p_data_fp32)
-
-                exp_avg, exp_inf = state["exp_avg"], state["exp_inf"]
-                beta1, beta2 = group["betas"]
-                eps = group["eps"]
-
-                state["step"] += 1
-
-                # Update biased first moment estimate.
-                exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
-
-                # Update the exponentially weighted infinity norm.
-                torch.max(
-                    exp_inf.mul_(beta2),
-                    grad.abs_(),
-                    out=exp_inf,
-                )
-
-                step_size = group["lr"]
-                if group["bias_correction"]:
-                    bias_correction = 1 - beta1 ** state["step"]
-                    step_size /= bias_correction
-
-                if group["weight_decay"] != 0:
-                    p_data_fp32.add_(
-                        p_data_fp32, alpha=-group["weight_decay"] * group["lr"]
-                    )
-
-                p_data_fp32.addcdiv_(exp_avg, exp_inf.add(eps), value=-step_size)
-
-                if p.data.dtype in {torch.float16, torch.bfloat16}:
-                    p.data.copy_(p_data_fp32)
-
-        return loss
diff --git a/spaces/nasttam/Image-and-3D-Model-Creator/PIFu/lib/renderer/camera.py b/spaces/nasttam/Image-and-3D-Model-Creator/PIFu/lib/renderer/camera.py
deleted file mode 100644
index e5c330a17e0166970428911a8f1ba92bb89f5034..0000000000000000000000000000000000000000
--- a/spaces/nasttam/Image-and-3D-Model-Creator/PIFu/lib/renderer/camera.py
+++ /dev/null
@@ -1,207 +0,0 @@
-import cv2
-import numpy as np
-
-from .glm import ortho
-
-
-class Camera:
-    def __init__(self, width=1600, height=1200):
-        # Focal Length
-        # equivalent 50mm
-        focal = np.sqrt(width * width + height * height)
-        self.focal_x = focal
-        self.focal_y = focal
-        # Principal Point Offset
-        self.principal_x = width / 2
-        self.principal_y = height / 2
-        # Axis Skew
-        self.skew = 0
-        # Image Size
-        self.width = width
-        self.height = height
-
-        self.near = 1
-        self.far = 10
-
-        # Camera Center
-        self.center = np.array([0, 0, 1.6])
-        self.direction = np.array([0, 0, -1])
-        self.right = np.array([1, 0, 0])
-        self.up = np.array([0, 1, 0])
-
-        self.ortho_ratio = None
-
-    def sanity_check(self):
-        self.center = self.center.reshape([-1])
-        self.direction = self.direction.reshape([-1])
-        self.right = self.right.reshape([-1])
-        self.up = self.up.reshape([-1])
-
-        assert len(self.center) == 3
-        assert len(self.direction) == 3
-        assert len(self.right) == 3
-        assert len(self.up) == 3
-
-    @staticmethod
-    def normalize_vector(v):
-        v_norm = np.linalg.norm(v)
-        return v if v_norm == 0 else v / v_norm
-
-    def get_real_z_value(self, z):
-        z_near = self.near
-        z_far = self.far
-        z_n = 2.0 * z - 1.0
-        z_e = 2.0 * z_near * z_far / (z_far + z_near - z_n * (z_far - z_near))
-        return z_e
-
-    def get_rotation_matrix(self):
-        rot_mat = np.eye(3)
-        s = self.right
-        s = self.normalize_vector(s)
-        rot_mat[0, :] = s
-        u = self.up
-        u = self.normalize_vector(u)
-        rot_mat[1, :] = -u
-        rot_mat[2, :] = self.normalize_vector(self.direction)
-
-        return rot_mat
-
-    def get_translation_vector(self):
-        rot_mat = self.get_rotation_matrix()
-        trans = -np.dot(rot_mat, self.center)
-        return trans
-
-    def get_intrinsic_matrix(self):
-        int_mat = np.eye(3)
-
-        int_mat[0, 0] = self.focal_x
-        int_mat[1, 1] = self.focal_y
-        int_mat[0, 1] = self.skew
-        int_mat[0, 2] = self.principal_x
-        int_mat[1, 2] = self.principal_y
-
-        return int_mat
-
-    def get_projection_matrix(self):
-        ext_mat = self.get_extrinsic_matrix()
-        int_mat = self.get_intrinsic_matrix()
-
-        return np.matmul(int_mat, ext_mat)
-
-    def get_extrinsic_matrix(self):
-        rot_mat = self.get_rotation_matrix()
-        int_mat = self.get_intrinsic_matrix()
-        trans = self.get_translation_vector()
-
-        extrinsic = np.eye(4)
-        extrinsic[:3, :3] = rot_mat
-        extrinsic[:3, 3] = trans
-
-        return extrinsic[:3, :]
-
-    def set_rotation_matrix(self, rot_mat):
-        self.direction = rot_mat[2, :]
-        self.up = -rot_mat[1, :]
-        self.right = rot_mat[0, :]
-
-    def set_intrinsic_matrix(self, int_mat):
-        self.focal_x = int_mat[0, 0]
-        self.focal_y = int_mat[1, 1]
-        self.skew = int_mat[0, 1]
-        self.principal_x = int_mat[0, 2]
-        self.principal_y = int_mat[1, 2]
-
-    def set_projection_matrix(self, proj_mat):
-        res = cv2.decomposeProjectionMatrix(proj_mat)
-        int_mat, rot_mat, camera_center_homo = res[0], res[1], res[2]
-        camera_center = camera_center_homo[0:3] / camera_center_homo[3]
-        camera_center = camera_center.reshape(-1)
-        int_mat = int_mat / int_mat[2][2]
-
-        self.set_intrinsic_matrix(int_mat)
-        self.set_rotation_matrix(rot_mat)
-        self.center = camera_center
-
-        self.sanity_check()
-
-    def get_gl_matrix(self):
-        z_near = self.near
-        z_far = self.far
-        rot_mat = self.get_rotation_matrix()
-        int_mat = self.get_intrinsic_matrix()
-        trans = self.get_translation_vector()
-
-        extrinsic = np.eye(4)
-        extrinsic[:3, :3] = rot_mat
-        extrinsic[:3, 3] = trans
-        axis_adj = np.eye(4)
-        axis_adj[2, 2] = -1
-        axis_adj[1, 1] = -1
-        model_view = np.matmul(axis_adj, extrinsic)
-
-        projective = np.zeros([4, 4])
-        projective[:2, :2] = int_mat[:2, :2]
-        projective[:2, 2:3] = -int_mat[:2, 2:3]
-        projective[3, 2] = -1
-        projective[2, 2] = (z_near + z_far)
-        projective[2, 3] = (z_near * z_far)
-
-        if self.ortho_ratio is None:
-            ndc = ortho(0, self.width, 0, self.height, z_near, z_far)
-            perspective = np.matmul(ndc, projective)
-        else:
-            perspective = ortho(-self.width * self.ortho_ratio / 2, self.width * self.ortho_ratio / 2,
-                                -self.height * self.ortho_ratio / 2, self.height * self.ortho_ratio / 2,
-                                z_near, z_far)
-
-        return perspective, model_view
-
-
-def KRT_from_P(proj_mat, normalize_K=True):
-    res = cv2.decomposeProjectionMatrix(proj_mat)
-    K, Rot, camera_center_homog = res[0], res[1], res[2]
-    camera_center = camera_center_homog[0:3] / camera_center_homog[3]
-    trans = -Rot.dot(camera_center)
-    if normalize_K:
-        K = K / K[2][2]
-    return K, Rot, trans
-
-
-def MVP_from_P(proj_mat, width, height, near=0.1, far=10000):
-    '''
-    Convert OpenCV camera calibration matrix to OpenGL projection and model view matrix
-    :param proj_mat: OpenCV camera projeciton matrix
-    :param width: Image width
-    :param height: Image height
-    :param near: Z near value
-    :param far: Z far value
-    :return: OpenGL projection matrix and model view matrix
-    '''
-    res = cv2.decomposeProjectionMatrix(proj_mat)
-    K, Rot, camera_center_homog = res[0], res[1], res[2]
-    camera_center = camera_center_homog[0:3] / camera_center_homog[3]
-    trans = -Rot.dot(camera_center)
-    K = K / K[2][2]
-
-    extrinsic = np.eye(4)
-    extrinsic[:3, :3] = Rot
-    extrinsic[:3, 3:4] = trans
-    axis_adj = np.eye(4)
-    axis_adj[2, 2] = -1
-    axis_adj[1, 1] = -1
-    model_view = np.matmul(axis_adj, extrinsic)
-
-    zFar = far
-    zNear = near
-    projective = np.zeros([4, 4])
-    projective[:2, :2] = K[:2, :2]
-    projective[:2, 2:3] = -K[:2, 2:3]
-    projective[3, 2] = -1
-    projective[2, 2] = (zNear + zFar)
-    projective[2, 3] = (zNear * zFar)
-
-    ndc = ortho(0, width, 0, height, zNear, zFar)
-
-    perspective = np.matmul(ndc, projective)
-
-    return perspective, model_view
diff --git a/spaces/nasttam/Image-and-3D-Model-Creator/PIFu/lib/renderer/glm.py b/spaces/nasttam/Image-and-3D-Model-Creator/PIFu/lib/renderer/glm.py
deleted file mode 100644
index 8be14b50f0d7edcde6328f1f805b392c8e3ab7e2..0000000000000000000000000000000000000000
--- a/spaces/nasttam/Image-and-3D-Model-Creator/PIFu/lib/renderer/glm.py
+++ /dev/null
@@ -1,125 +0,0 @@
-import numpy as np
-
-
-def vec3(x, y, z):
-    return np.array([x, y, z], dtype=np.float32)
-
-
-def radians(v):
-    return np.radians(v)
-
-
-def identity():
-    return np.identity(4, dtype=np.float32)
-
-
-def empty():
-    return np.zeros([4, 4], dtype=np.float32)
-
-
-def magnitude(v):
-    return np.linalg.norm(v)
-
-
-def normalize(v):
-    m = magnitude(v)
-    return v if m == 0 else v / m
-
-
-def dot(u, v):
-    return np.sum(u * v)
-
-
-def cross(u, v):
-    res = vec3(0, 0, 0)
-    res[0] = u[1] * v[2] - u[2] * v[1]
-    res[1] = u[2] * v[0] - u[0] * v[2]
-    res[2] = u[0] * v[1] - u[1] * v[0]
-    return res
-
-
-# below functions can be optimized
-
-def translate(m, v):
-    res = np.copy(m)
-    res[:, 3] = m[:, 0] * v[0] + m[:, 1] * v[1] + m[:, 2] * v[2] + m[:, 3]
-    return res
-
-
-def rotate(m, angle, v):
-    a = angle
-    c = np.cos(a)
-    s = np.sin(a)
-
-    axis = normalize(v)
-    temp = (1 - c) * axis
-
-    rot = empty()
-    rot[0][0] = c + temp[0] * axis[0]
-    rot[0][1] = temp[0] * axis[1] + s * axis[2]
-    rot[0][2] = temp[0] * axis[2] - s * axis[1]
-
-    rot[1][0] = temp[1] * axis[0] - s * axis[2]
-    rot[1][1] = c + temp[1] * axis[1]
-    rot[1][2] = temp[1] * axis[2] + s * axis[0]
-
-    rot[2][0] = temp[2] * axis[0] + s * axis[1]
-    rot[2][1] = temp[2] * axis[1] - s * axis[0]
-    rot[2][2] = c + temp[2] * axis[2]
-
-    res = empty()
-    res[:, 0] = m[:, 0] * rot[0][0] + m[:, 1] * rot[0][1] + m[:, 2] * rot[0][2]
-    res[:, 1] = m[:, 0] * rot[1][0] + m[:, 1] * rot[1][1] + m[:, 2] * rot[1][2]
-    res[:, 2] = m[:, 0] * rot[2][0] + m[:, 1] * rot[2][1] + m[:, 2] * rot[2][2]
-    res[:, 3] = m[:, 3]
-    return res
-
-
-def perspective(fovy, aspect, zNear, zFar):
-    tanHalfFovy = np.tan(fovy / 2)
-
-    res = empty()
-    res[0][0] = 1 / (aspect * tanHalfFovy)
-    res[1][1] = 1 / (tanHalfFovy)
-    res[2][3] = -1
-    res[2][2] = - (zFar + zNear) / (zFar - zNear)
-    res[3][2] = -(2 * zFar * zNear) / (zFar - zNear)
-
-    return res.T
-
-
-def ortho(left, right, bottom, top, zNear, zFar):
-    # res = np.ones([4, 4], dtype=np.float32)
-    res = identity()
-    res[0][0] = 2 / (right - left)
-    res[1][1] = 2 / (top - bottom)
-    res[2][2] = - 2 / (zFar - zNear)
-    res[3][0] = - (right + left) / (right - left)
-    res[3][1] = - (top + bottom) / (top - bottom)
-    res[3][2] = - (zFar + zNear) / (zFar - zNear)
-    return res.T
-
-
-def lookat(eye, center, up):
-    f = normalize(center - eye)
-    s = normalize(cross(f, up))
-    u = cross(s, f)
-
-    res = identity()
-    res[0][0] = s[0]
-    res[1][0] = s[1]
-    res[2][0] = s[2]
-    res[0][1] = u[0]
-    res[1][1] = u[1]
-    res[2][1] = u[2]
-    res[0][2] = -f[0]
-    res[1][2] = -f[1]
-    res[2][2] = -f[2]
-    res[3][0] = -dot(s, eye)
-    res[3][1] = -dot(u, eye)
-    res[3][2] = -dot(f, eye)
-    return res.T
-
-
-def transform(d, m):
-    return np.dot(m, d.T).T
diff --git a/spaces/nathanTQ/ChatDev/camel/prompts/prompt_templates.py b/spaces/nathanTQ/ChatDev/camel/prompts/prompt_templates.py
deleted file mode 100644
index cc1cb40c23d7f05d60b515502da4765d773e3078..0000000000000000000000000000000000000000
--- a/spaces/nathanTQ/ChatDev/camel/prompts/prompt_templates.py
+++ /dev/null
@@ -1,117 +0,0 @@
-# =========== Copyright 2023 @ CAMEL-AI.org. 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 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-import warnings
-from typing import Any, Optional
-
-from camel.prompts import TaskPromptTemplateDict, TextPrompt
-from camel.typing import RoleType, TaskType
-
-
-class PromptTemplateGenerator:
-    r"""A class for generating prompt templates for tasks.
-
-    Args:
-        task_prompt_template_dict (TaskPromptTemplateDict, optional):
-            A dictionary of task prompt templates for each task type. If not
-            provided, an empty dictionary is used as default.
-    """
-
-    def __init__(
-        self,
-        task_prompt_template_dict: Optional[TaskPromptTemplateDict] = None,
-    ) -> None:
-        self.task_prompt_template_dict = (task_prompt_template_dict or TaskPromptTemplateDict())
-
-    def get_prompt_from_key(self, task_type: TaskType, key: Any) -> TextPrompt:
-        r"""Generates a text prompt using the specified :obj:`task_type` and
-        :obj:`key`.
-
-        Args:
-            task_type (TaskType): The type of task.
-            key (Any): The key used to generate the prompt.
-
-        Returns:
-            TextPrompt: The generated text prompt.
-
-        Raises:
-            KeyError: If failed to generate prompt using the specified
-                :obj:`task_type` and :obj:`key`.
-        """
-        try:
-            print(task_type, key)
-            return self.task_prompt_template_dict[task_type][key]
-
-        except KeyError:
-            raise KeyError("Failed to get generate prompt template for "
-                           f"task: {task_type.value} from key: {key}.")
-
-    def get_system_prompt(
-        self,
-        task_type: TaskType,
-        role_type: RoleType,
-    ) -> TextPrompt:
-        r"""Generates a text prompt for the system role, using the specified
-        :obj:`task_type` and :obj:`role_type`.
-
-        Args:
-            task_type (TaskType): The type of task.
-            role_type (RoleType): The type of role, either "USER" or
-                "ASSISTANT".
-
-        Returns:
-            TextPrompt: The generated text prompt.
-
-        Raises:
-            KeyError: If failed to generate prompt using the specified
-                :obj:`task_type` and :obj:`role_type`.
-        """
-        try:
-            return self.get_prompt_from_key(task_type, role_type)
-
-        except KeyError:
-            prompt = "You are a helpful assistant."
-
-            warnings.warn("Failed to get system prompt template for "
-                          f"task: {task_type.value}, role: {role_type.value}. "
-                          f"Set template to: {prompt}")
-
-        return TextPrompt(prompt)
-
-    def get_generate_tasks_prompt(
-        self,
-        task_type: TaskType,
-    ) -> TextPrompt:
-        r"""Gets the prompt for generating tasks for a given task type.
-
-        Args:
-            task_type (TaskType): The type of the task.
-
-        Returns:
-            TextPrompt: The generated prompt for generating tasks.
-        """
-        return self.get_prompt_from_key(task_type, "generate_tasks")
-
-    def get_task_specify_prompt(
-        self,
-        task_type: TaskType,
-    ) -> TextPrompt:
-        r"""Gets the prompt for specifying a task for a given task type.
-
-        Args:
-            task_type (TaskType): The type of the task.
-
-        Returns:
-            TextPrompt: The generated prompt for specifying a task.
-        """
-        return self.get_prompt_from_key(task_type, "task_specify_prompt")
diff --git a/spaces/netiMophi/DreamlikeArt-Diffusion-1.0/Matematica Concreta Knuth Pdf 49.md b/spaces/netiMophi/DreamlikeArt-Diffusion-1.0/Matematica Concreta Knuth Pdf 49.md
deleted file mode 100644
index 08bad0d8982fff225e630863d1eb2dd7fbf7b15e..0000000000000000000000000000000000000000
--- a/spaces/netiMophi/DreamlikeArt-Diffusion-1.0/Matematica Concreta Knuth Pdf 49.md	
+++ /dev/null
@@ -1,14 +0,0 @@
-<br />
-<h1>Matematica Concreta Knuth Pdf 49: A Review of Concrete Mathematics by Graham, Knuth, and Patashnik</h1>
-<p>Concrete Mathematics is a classic textbook on discrete mathematics, written by Ronald L. Graham, Donald E. Knuth, and Oren Patashnik. The book covers topics such as recurrence relations, generating functions, binomial coefficients, asymptotic analysis, number theory, and combinatorics. The book is based on the course Concrete Mathematics taught by Knuth at Stanford University from 1970 to 1989.</p>
-<h2>matematica concreta knuth pdf 49</h2><br /><p><b><b>Download</b> ---> <a href="https://urlcod.com/2uIbe4">https://urlcod.com/2uIbe4</a></b></p><br /><br />
-<p>The book is well-known for its rigorous and elegant presentation of the mathematical concepts and techniques, as well as its numerous exercises and examples. The book also includes important new material about the revolutionary Gosper-Zeilberger algorithm for mechanical summation, which was added in the second edition published in 1994. The book provides complete answers for more than 500 exercises, making it an indispensable text and reference not only for computer scientists, but for serious users of mathematics in virtually every discipline.</p>
-<p>The title of the book is a pun on the term "abstract algebra", which is another branch of mathematics that deals with algebraic structures such as groups, rings, and fields. The authors explain that concrete mathematics is "a blend of continuous and discrete mathematics", where "continuous mathematics" refers to calculus and its generalizations. The term "concrete" also suggests that the mathematics in the book is more tangible and practical than abstract.</p>
-<p>The book can be downloaded as a PDF file from various online sources, such as Archive.org[^1^] or SoundCloud[^3^]. However, these sources may not have the latest version of the book or may contain errors or omissions. Therefore, it is recommended to purchase a hard copy of the book from a reputable publisher or bookstore, such as Addison-Wesley[^2^] or Amazon.com.</p>
-
-<p>Concrete Mathematics is not only a theoretical book, but also a practical one. The book shows how the mathematical concepts and techniques can be applied to various problems in computer science, such as sorting, searching, cryptography, coding theory, computational geometry, combinatorial optimization, and algorithm analysis. The book also illustrates how concrete mathematics can help discover subtle patterns in data, such as Fibonacci numbers, Catalan numbers, Stirling numbers, and harmonic numbers.</p>
-<p>The book has been translated into several languages, such as Chinese, Italian, Japanese, Portuguese, Russian, Polish, Hungarian, Spanish, French, Greek, Korean, Croatian, and Macedonian. The book has received positive reviews from many mathematicians and computer scientists, who praise its clarity, rigor, depth, breadth, and humor. The book is also recommended by Knuth as a prerequisite for reading his magnum opus The Art of Computer Programming.</p>
-<p></p>
-<p>Concrete Mathematics is a book that can enrich the mathematical knowledge and skills of anyone who is interested in computer science or mathematics. The book is suitable for undergraduate and graduate students, as well as researchers and practitioners. The book is also enjoyable for anyone who loves mathematics and wants to learn more about its beauty and power.</p> 81aa517590<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/netiMophi/DreamlikeArt-Diffusion-1.0/Men In Black 3 4 Telugu Dubbed Movie [Extra Quality] Free Download.md b/spaces/netiMophi/DreamlikeArt-Diffusion-1.0/Men In Black 3 4 Telugu Dubbed Movie [Extra Quality] Free Download.md
deleted file mode 100644
index 6ead60f8cfb7b49a0c2d21dd0f70c81a9512368b..0000000000000000000000000000000000000000
--- a/spaces/netiMophi/DreamlikeArt-Diffusion-1.0/Men In Black 3 4 Telugu Dubbed Movie [Extra Quality] Free Download.md	
+++ /dev/null
@@ -1,26 +0,0 @@
-<br />
-<h1>Men In Black 3 4 Telugu Dubbed Movie Free Download: How to Watch the Sci-Fi Comedy Series in Telugu</h1>
-<p>Men In Black is a popular sci-fi comedy film series that follows the adventures of Agents J and K, who work for a secret organization that monitors and regulates extraterrestrial activity on Earth. The first film was released in 1997, followed by two sequels in 2002 and 2012. The fourth film, Men In Black: International, was a spin-off that featured new characters and locations.</p>
-<h2>Men In Black 3 4 telugu dubbed movie free download</h2><br /><p><b><b>Download</b> >>> <a href="https://urlcod.com/2uIbow">https://urlcod.com/2uIbow</a></b></p><br /><br />
-<p>If you are a fan of Men In Black and want to watch the series in Telugu, you might be wondering how to do that. Well, you have come to the right place. In this article, we will tell you how to free download Men In Black 3 4 Telugu dubbed movie in full HD quality.</p>
-<h2>How to Free Download Men In Black 3 4 Telugu Dubbed Movie</h2>
-<p>There are many websites that offer Telugu dubbed versions of Hollywood movies for free download. However, not all of them are safe or legal. Some of them may contain viruses, malware, or pop-up ads that can harm your device or compromise your privacy. Moreover, downloading pirated content is illegal and can get you into trouble with the law.</p>
-<p>Therefore, we recommend that you use a reliable and legal source to watch Men In Black 3 4 Telugu dubbed movie online or offline. One such source is Movies Anywhere[^4^], a digital service that lets you buy, stream, or download movies from various studios and platforms. You can access Movies Anywhere on your web browser, mobile device, smart TV, or streaming device.</p>
-<p>To watch Men In Black 3 4 Telugu dubbed movie on Movies Anywhere, you need to follow these steps:</p>
-<ol>
-<li>Create an account on Movies Anywhere and link it to your preferred retailer (such as Amazon Prime Video, Google Play, iTunes, etc.).</li>
-<li>Search for Men In Black 3 or Men In Black: International on Movies Anywhere and buy or rent the movie from your linked retailer.</li>
-<li>Select the Telugu audio option from the menu and enjoy the movie.</li>
-</ol>
-<p>Note that you need to have a valid payment method and a stable internet connection to use Movies Anywhere. Also, the availability of Telugu audio may vary depending on the region and the retailer.</p>
-<h2>Other Tips About Men In Black 3 4 Telugu Dubbed Movie</h2>
-<p>Here are some other tips and information about Men In Black 3 4 Telugu dubbed movie that you might find useful:</p>
-<ul>
-<li>The plot summary of Men In Black 3 is: In Men in Black 3, Agents J (Will Smith) and K (Tommy Lee Jones) are back... in time. J has seen some inexplicable things in his 15 years with the Men in Black, but nothing, not even aliens, perplexes him as much as his wry, reticent partner. But when K’s life and the fate of the planet are put at stake, Agent J will have to travel back in time to put things right. J discovers that there are secrets to the universe that K never told him – secrets that will reveal themselves as he teams up with the young Agent K (Josh Brolin) to save his partner, the agency and the future of humankind[^4^].</li>
-<li>The plot summary of Men In Black: International is: The Men in Black have always protected the Earth from the scum of the universe. In this new adventure, they tackle their biggest threat to date: a mole in the Men in Black organization. Agent H (Chris Hemsworth) and Agent M (Tessa Thompson) team up to stop a sinister alien force that is using a powerful weapon to destroy planets[^5^].</li>
-<li>The genre of Men In Black 3 4 is sci-fi comedy with elements of action and adventure.</li>
-<li>The resolution options for Men In Black 3 4 Telugu dubbed movie are 720p, 1080p, or 4K depending on your device and internet speed.</li>
-<li>The download format for Men In Black 3 4 Telugu dubbed movie</p>
-<p></p> 7b8c122e87<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/noelshin/selfmask/networks/module_helper.py b/spaces/noelshin/selfmask/networks/module_helper.py
deleted file mode 100644
index 7d9a55e55b71f1d4f6951c625d90367a77d8f6d9..0000000000000000000000000000000000000000
--- a/spaces/noelshin/selfmask/networks/module_helper.py
+++ /dev/null
@@ -1,176 +0,0 @@
-#!/usr/bin/env python
-# -*- coding:utf-8 -*-
-# Author: Donny You (youansheng@gmail.com)
-import os
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-try:
-    from urllib import urlretrieve
-except ImportError:
-    from urllib.request import urlretrieve
-
-
-class FixedBatchNorm(nn.BatchNorm2d):
-    def forward(self, input):
-        return F.batch_norm(input, self.running_mean, self.running_var, self.weight, self.bias, training=False, eps=self.eps)
-
-
-class ModuleHelper(object):
-    @staticmethod
-    def BNReLU(num_features, norm_type=None, **kwargs):
-        if norm_type == 'batchnorm':
-            return nn.Sequential(
-                nn.BatchNorm2d(num_features, **kwargs),
-                nn.ReLU()
-            )
-        elif norm_type == 'encsync_batchnorm':
-            from encoding.nn import BatchNorm2d
-            return nn.Sequential(
-                BatchNorm2d(num_features, **kwargs),
-                nn.ReLU()
-            )
-        elif norm_type == 'instancenorm':
-            return nn.Sequential(
-                nn.InstanceNorm2d(num_features, **kwargs),
-                nn.ReLU()
-            )
-        elif norm_type == 'fixed_batchnorm':
-            return nn.Sequential(
-                FixedBatchNorm(num_features, **kwargs),
-                nn.ReLU()
-            )
-        else:
-            raise ValueError('Not support BN type: {}.'.format(norm_type))
-
-    @staticmethod
-    def BatchNorm3d(norm_type=None, ret_cls=False):
-        if norm_type == 'batchnorm':
-            return nn.BatchNorm3d
-        elif norm_type == 'encsync_batchnorm':
-            from encoding.nn import BatchNorm3d
-            return BatchNorm3d
-        elif norm_type == 'instancenorm':
-            return nn.InstanceNorm3d
-        else:
-            raise ValueError('Not support BN type: {}.'.format(norm_type))
-
-    @staticmethod
-    def BatchNorm2d(norm_type=None, ret_cls=False):
-        if norm_type == 'batchnorm':
-            return nn.BatchNorm2d
-        elif norm_type == 'encsync_batchnorm':
-            from encoding.nn import BatchNorm2d
-            return BatchNorm2d
-
-        elif norm_type == 'instancenorm':
-            return nn.InstanceNorm2d
-        else:
-            raise ValueError('Not support BN type: {}.'.format(norm_type))
-
-    @staticmethod
-    def BatchNorm1d(norm_type=None, ret_cls=False):
-        if norm_type == 'batchnorm':
-            return nn.BatchNorm1d
-        elif norm_type == 'encsync_batchnorm':
-            from encoding.nn import BatchNorm1d
-            return BatchNorm1d
-        elif norm_type == 'instancenorm':
-            return nn.InstanceNorm1d
-        else:
-            raise ValueError('Not support BN type: {}.'.format(norm_type))
-
-    @staticmethod
-    def load_model(model, pretrained=None, all_match=True, map_location='cpu'):
-        if pretrained is None:
-            return model
-
-        if not os.path.exists(pretrained):
-            pretrained = pretrained.replace("..", "/home/gishin-temp/projects/open_set/segmentation")
-            if os.path.exists(pretrained):
-                pass
-            else:
-                raise FileNotFoundError('{} not exists.'.format(pretrained))
-
-        print('Loading pretrained model:{}'.format(pretrained))
-        if all_match:
-            pretrained_dict = torch.load(pretrained, map_location=map_location)
-            model_dict = model.state_dict()
-            load_dict = dict()
-            for k, v in pretrained_dict.items():
-                if 'prefix.{}'.format(k) in model_dict:
-                    load_dict['prefix.{}'.format(k)] = v
-                else:
-                    load_dict[k] = v
-            model.load_state_dict(load_dict)
-
-        else:
-            pretrained_dict = torch.load(pretrained)
-            model_dict = model.state_dict()
-            load_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
-            print('Matched Keys: {}'.format(load_dict.keys()))
-            model_dict.update(load_dict)
-            model.load_state_dict(model_dict)
-
-        return model
-
-    @staticmethod
-    def load_url(url, map_location=None):
-        model_dir = os.path.join('~', '.TorchCV', 'model')
-        if not os.path.exists(model_dir):
-            os.makedirs(model_dir)
-
-        filename = url.split('/')[-1]
-        cached_file = os.path.join(model_dir, filename)
-        if not os.path.exists(cached_file):
-            print('Downloading: "{}" to {}\n'.format(url, cached_file))
-            urlretrieve(url, cached_file)
-
-        print('Loading pretrained model:{}'.format(cached_file))
-        return torch.load(cached_file, map_location=map_location)
-
-    @staticmethod
-    def constant_init(module, val, bias=0):
-        nn.init.constant_(module.weight, val)
-        if hasattr(module, 'bias') and module.bias is not None:
-            nn.init.constant_(module.bias, bias)
-
-    @staticmethod
-    def xavier_init(module, gain=1, bias=0, distribution='normal'):
-        assert distribution in ['uniform', 'normal']
-        if distribution == 'uniform':
-            nn.init.xavier_uniform_(module.weight, gain=gain)
-        else:
-            nn.init.xavier_normal_(module.weight, gain=gain)
-        if hasattr(module, 'bias') and module.bias is not None:
-            nn.init.constant_(module.bias, bias)
-
-    @staticmethod
-    def normal_init(module, mean=0, std=1, bias=0):
-        nn.init.normal_(module.weight, mean, std)
-        if hasattr(module, 'bias') and module.bias is not None:
-            nn.init.constant_(module.bias, bias)
-
-    @staticmethod
-    def uniform_init(module, a=0, b=1, bias=0):
-        nn.init.uniform_(module.weight, a, b)
-        if hasattr(module, 'bias') and module.bias is not None:
-            nn.init.constant_(module.bias, bias)
-
-    @staticmethod
-    def kaiming_init(module,
-                     mode='fan_in',
-                     nonlinearity='leaky_relu',
-                     bias=0,
-                     distribution='normal'):
-        assert distribution in ['uniform', 'normal']
-        if distribution == 'uniform':
-            nn.init.kaiming_uniform_(
-                module.weight, mode=mode, nonlinearity=nonlinearity)
-        else:
-            nn.init.kaiming_normal_(
-                module.weight, mode=mode, nonlinearity=nonlinearity)
-        if hasattr(module, 'bias') and module.bias is not None:
-            nn.init.constant_(module.bias, bias)
-
diff --git a/spaces/ntt123/WaveGRU-Text-To-Speech/app.py b/spaces/ntt123/WaveGRU-Text-To-Speech/app.py
deleted file mode 100644
index 1fcfc69d670d9016ceee3402578708b91a200f50..0000000000000000000000000000000000000000
--- a/spaces/ntt123/WaveGRU-Text-To-Speech/app.py
+++ /dev/null
@@ -1,60 +0,0 @@
-## build wavegru-cpp
-# import os
-# os.system("./bazelisk-linux-amd64 clean --expunge")
-# os.system("./bazelisk-linux-amd64 build wavegru_mod -c opt --copt=-march=native")
-
-# install espeak
-import os
-
-if not os.path.isdir("./espeak"):
-    os.system("bash ./install_espeak_ng.sh")
-
-import gradio as gr
-from inference import load_tacotron_model, load_wavegru_net, mel_to_wav, text_to_mel
-from wavegru_cpp import extract_weight_mask, load_wavegru_cpp
-
-
-alphabet, tacotron_net, tacotron_config = load_tacotron_model(
-    "./alphabet.txt", "./tacotron.toml", "./tacotrons_ljs_24k_v1_0300000.ckpt"
-)
-
-wavegru_config, wavegru_net = load_wavegru_net(
-    "./wavegru.yaml", "./wavegru_vocoder_1024_v4_1320000.ckpt"
-)
-
-wave_cpp_weight_mask = extract_weight_mask(wavegru_net)
-wavecpp = load_wavegru_cpp(
-    wave_cpp_weight_mask, wavegru_config["upsample_factors"][-1]
-)
-
-
-def speak(text):
-    mel = text_to_mel(tacotron_net, text, alphabet, tacotron_config)
-    y = mel_to_wav(wavegru_net, wavecpp, mel, wavegru_config)
-    return 24_000, y
-
-
-title = "WaveGRU-TTS"
-description = "WaveGRU text-to-speech demo."
-
-gr.Interface(
-    fn=speak,
-    inputs="text",
-    examples=[
-        "This is a test!",
-        "President Trump met with other leaders at the Group of 20 conference.",
-        "The buses aren't the problem, they actually provide a solution.",
-        "Generative adversarial network or variational auto-encoder.",
-        "Basilar membrane and otolaryngology are not auto-correlations.",
-        "There are several variations on the full gated unit, with gating done using the previous hidden state and the bias in various combinations, and a simplified form called minimal gated unit.",
-        "October arrived, spreading a damp chill over the grounds and into the castle. Madam Pomfrey, the nurse, was kept busy by a sudden spate of colds among the staff and students.",
-        "Artificial intelligence is intelligence demonstrated by machines, as opposed to natural intelligence displayed by animals including humans.",
-        'Uncle Vernon entered the kitchen as Harry was turning over the bacon. "Comb your hair!" he barked, by way of a morning greeting. About once a week, Uncle Vernon looked over the top of his newspaper and shouted that Harry needed a haircut. Harry must have had more haircuts than the rest of the boys in his class put together, but it made no difference, his hair simply grew that way - all over the place.',
-    ],
-    outputs="audio",
-    title=title,
-    description=description,
-    theme="default",
-    allow_screenshot=False,
-    allow_flagging="never",
-).launch(enable_queue=True)
diff --git a/spaces/oguzakif/video-object-remover/FGT_codes/FGT/models/transformer_base/ffn_base.py b/spaces/oguzakif/video-object-remover/FGT_codes/FGT/models/transformer_base/ffn_base.py
deleted file mode 100644
index de3086620ef4dc52b9576424d6d1b4bb53cef63b..0000000000000000000000000000000000000000
--- a/spaces/oguzakif/video-object-remover/FGT_codes/FGT/models/transformer_base/ffn_base.py
+++ /dev/null
@@ -1,114 +0,0 @@
-import torch
-from functools import reduce
-import torch.nn as nn
-import torch.nn.functional as F
-from functools import partial
-
-
-class FeedForward(nn.Module):
-    def __init__(self, frame_hidden, mlp_ratio, n_vecs, t2t_params, p):
-        """
-
-        Args:
-            frame_hidden: hidden size of frame features
-            mlp_ratio: mlp ratio in the middle layer of the transformers
-            n_vecs: number of vectors in the transformer
-            t2t_params: dictionary -> {'kernel_size': kernel_size, 'stride': stride, 'padding': padding, 'output_size': output_shape}
-            p: dropout rate, 0 by default
-        """
-        super(FeedForward, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Linear(frame_hidden, frame_hidden * mlp_ratio),
-            nn.ReLU(inplace=True),
-            nn.Dropout(p),
-            nn.Linear(frame_hidden * mlp_ratio, frame_hidden),
-            nn.Dropout(p)
-        )
-
-    def forward(self, x, n_vecs=0, output_h=0, output_w=0):
-        x = self.conv(x)
-        return x
-
-
-class FusionFeedForward(nn.Module):
-    def __init__(self, frame_hidden, mlp_ratio, n_vecs, t2t_params, p):
-        super(FusionFeedForward, self).__init__()
-        self.kernel_shape = reduce((lambda x, y: x * y), t2t_params['kernel_size'])
-        self.t2t_params = t2t_params
-        hidden_size = self.kernel_shape * mlp_ratio
-        self.conv1 = nn.Linear(frame_hidden, hidden_size)
-        self.conv2 = nn.Sequential(
-            nn.ReLU(inplace=True),
-            nn.Dropout(p),
-            nn.Linear(hidden_size, frame_hidden),
-            nn.Dropout(p)
-        )
-        assert t2t_params is not None and n_vecs is not None
-        tp = t2t_params.copy()
-        self.fold = nn.Fold(**tp)
-        del tp['output_size']
-        self.unfold = nn.Unfold(**tp)
-        self.n_vecs = n_vecs
-
-    def forward(self, x, n_vecs=0, output_h=0, output_w=0):
-        x = self.conv1(x)
-        b, n, c = x.size()
-        if n_vecs != 0:
-            normalizer = x.new_ones(b, n, self.kernel_shape).view(-1, n_vecs, self.kernel_shape).permute(0, 2, 1)
-            x = self.unfold(F.fold(x.view(-1, n_vecs, c).permute(0, 2, 1), output_size=(output_h, output_w),
-                                   kernel_size=self.t2t_params['kernel_size'], stride=self.t2t_params['stride'],
-                                   padding=self.t2t_params['padding']) / F.fold(normalizer,
-                                                                                output_size=(output_h, output_w),
-                                                                                kernel_size=self.t2t_params[
-                                                                                    'kernel_size'],
-                                                                                stride=self.t2t_params['stride'],
-                                                                                padding=self.t2t_params[
-                                                                                    'padding'])).permute(0,
-                                                                                                         2,
-                                                                                                         1).contiguous().view(
-                b, n, c)
-        else:
-            normalizer = x.new_ones(b, n, self.kernel_shape).view(-1, self.n_vecs, self.kernel_shape).permute(0, 2, 1)
-            x = self.unfold(self.fold(x.view(-1, self.n_vecs, c).permute(0, 2, 1)) / self.fold(normalizer)).permute(0,
-                                                                                                                    2,
-                                                                                                                    1).contiguous().view(
-                b, n, c)
-        x = self.conv2(x)
-        return x
-
-
-class ResidualBlock_noBN(nn.Module):
-    """Residual block w/o BN
-    ---Conv-ReLU-Conv-+-
-     |________________|
-    """
-
-    def __init__(self, nf=64):
-        super(ResidualBlock_noBN, self).__init__()
-        self.conv1 = nn.Conv2d(nf, nf, kernel_size=3, stride=1, padding=1, bias=True)
-        self.conv2 = nn.Conv2d(nf, nf, kernel_size=3, stride=1, padding=1, bias=True)
-        self.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)
-
-    def forward(self, x):
-        """
-
-        Args:
-            x: with shape of [b, c, t, h, w]
-
-        Returns: processed features with shape [b, c, t, h, w]
-
-        """
-        identity = x
-        out = self.lrelu(self.conv1(x))
-        out = self.conv2(out)
-        out = identity + out
-        # Remove ReLU at the end of the residual block
-        # http://torch.ch/blog/2016/02/04/resnets.html
-        return out
-
-
-def make_layer(block, n_layers):
-    layers = []
-    for _ in range(n_layers):
-        layers.append(block())
-    return nn.Sequential(*layers)
diff --git a/spaces/oguzakif/video-object-remover/FGT_codes/LAFC/data/util/flow_utils/region_fill.py b/spaces/oguzakif/video-object-remover/FGT_codes/LAFC/data/util/flow_utils/region_fill.py
deleted file mode 100644
index 603c78aadc312b07a2eb7c99dc9439a2a47dfee7..0000000000000000000000000000000000000000
--- a/spaces/oguzakif/video-object-remover/FGT_codes/LAFC/data/util/flow_utils/region_fill.py
+++ /dev/null
@@ -1,142 +0,0 @@
-import numpy as np
-import cv2
-from scipy import sparse
-from scipy.sparse.linalg import spsolve
-
-
-# Laplacian filling
-def regionfill(I, mask, factor=1.0):
-    if np.count_nonzero(mask) == 0:
-        return I.copy()
-    resize_mask = cv2.resize(
-        mask.astype(float), (0, 0), fx=factor, fy=factor) > 0
-    resize_I = cv2.resize(I.astype(float), (0, 0), fx=factor, fy=factor)
-    maskPerimeter = findBoundaryPixels(resize_mask)
-    regionfillLaplace(resize_I, resize_mask, maskPerimeter)
-    resize_I = cv2.resize(resize_I, (I.shape[1], I.shape[0]))
-    resize_I[mask == 0] = I[mask == 0]
-    return resize_I
-
-
-def findBoundaryPixels(mask):
-    kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
-    maskDilated = cv2.dilate(mask.astype(float), kernel)
-    return (maskDilated > 0) & (mask == 0)
-
-
-def regionfillLaplace(I, mask, maskPerimeter):
-    height, width = I.shape
-    rightSide = formRightSide(I, maskPerimeter)
-
-    # Location of mask pixels
-    maskIdx = np.where(mask)
-
-    # Only keep values for pixels that are in the mask
-    rightSide = rightSide[maskIdx]
-
-    # Number the mask pixels in a grid matrix
-    grid = -np.ones((height, width))
-    grid[maskIdx] = range(0, maskIdx[0].size)
-    # Pad with zeros to avoid "index out of bounds" errors in the for loop
-    grid = padMatrix(grid)
-    gridIdx = np.where(grid >= 0)
-
-    # Form the connectivity matrix D=sparse(i,j,s)
-    # Connect each mask pixel to itself
-    i = np.arange(0, maskIdx[0].size)
-    j = np.arange(0, maskIdx[0].size)
-    # The coefficient is the number of neighbors over which we average
-    numNeighbors = computeNumberOfNeighbors(height, width)
-    s = numNeighbors[maskIdx]
-    # Now connect the N,E,S,W neighbors if they exist
-    for direction in ((-1, 0), (0, 1), (1, 0), (0, -1)):
-        # Possible neighbors in the current direction
-        neighbors = grid[gridIdx[0] + direction[0], gridIdx[1] + direction[1]]
-        # ConDnect mask points to neighbors with -1's
-        index = (neighbors >= 0)
-        i = np.concatenate((i, grid[gridIdx[0][index], gridIdx[1][index]]))
-        j = np.concatenate((j, neighbors[index]))
-        s = np.concatenate((s, -np.ones(np.count_nonzero(index))))
-
-    D = sparse.coo_matrix((s, (i.astype(int), j.astype(int)))).tocsr()
-    sol = spsolve(D, rightSide)
-    I[maskIdx] = sol
-    return I
-
-
-def formRightSide(I, maskPerimeter):
-    height, width = I.shape
-    perimeterValues = np.zeros((height, width))
-    perimeterValues[maskPerimeter] = I[maskPerimeter]
-    rightSide = np.zeros((height, width))
-
-    rightSide[1:height - 1, 1:width - 1] = (
-        perimeterValues[0:height - 2, 1:width - 1] +
-        perimeterValues[2:height, 1:width - 1] +
-        perimeterValues[1:height - 1, 0:width - 2] +
-        perimeterValues[1:height - 1, 2:width])
-
-    rightSide[1:height - 1, 0] = (
-        perimeterValues[0:height - 2, 0] + perimeterValues[2:height, 0] +
-        perimeterValues[1:height - 1, 1])
-
-    rightSide[1:height - 1, width - 1] = (
-        perimeterValues[0:height - 2, width - 1] +
-        perimeterValues[2:height, width - 1] +
-        perimeterValues[1:height - 1, width - 2])
-
-    rightSide[0, 1:width - 1] = (
-        perimeterValues[1, 1:width - 1] + perimeterValues[0, 0:width - 2] +
-        perimeterValues[0, 2:width])
-
-    rightSide[height - 1, 1:width - 1] = (
-        perimeterValues[height - 2, 1:width - 1] +
-        perimeterValues[height - 1, 0:width - 2] +
-        perimeterValues[height - 1, 2:width])
-
-    rightSide[0, 0] = perimeterValues[0, 1] + perimeterValues[1, 0]
-    rightSide[0, width - 1] = (
-        perimeterValues[0, width - 2] + perimeterValues[1, width - 1])
-    rightSide[height - 1, 0] = (
-        perimeterValues[height - 2, 0] + perimeterValues[height - 1, 1])
-    rightSide[height - 1, width - 1] = (perimeterValues[height - 2, width - 1] +
-                                        perimeterValues[height - 1, width - 2])
-    return rightSide
-
-
-def computeNumberOfNeighbors(height, width):
-    # Initialize
-    numNeighbors = np.zeros((height, width))
-    # Interior pixels have 4 neighbors
-    numNeighbors[1:height - 1, 1:width - 1] = 4
-    # Border pixels have 3 neighbors
-    numNeighbors[1:height - 1, (0, width - 1)] = 3
-    numNeighbors[(0, height - 1), 1:width - 1] = 3
-    # Corner pixels have 2 neighbors
-    numNeighbors[(0, 0, height - 1, height - 1), (0, width - 1, 0,
-                                                  width - 1)] = 2
-    return numNeighbors
-
-
-def padMatrix(grid):
-    height, width = grid.shape
-    gridPadded = -np.ones((height + 2, width + 2))
-    gridPadded[1:height + 1, 1:width + 1] = grid
-    gridPadded = gridPadded.astype(grid.dtype)
-    return gridPadded
-
-
-if __name__ == '__main__':
-    import time
-    x = np.linspace(0, 255, 500)
-    xv, _ = np.meshgrid(x, x)
-    image = ((xv + np.transpose(xv)) / 2.0).astype(int)
-    mask = np.zeros((500, 500))
-    mask[100:259, 100:259] = 1
-    mask = (mask > 0)
-    image[mask] = 0
-    st = time.time()
-    inpaint = regionfill(image, mask, 0.5).astype(np.uint8)
-    print(time.time() - st)
-    cv2.imshow('img', np.concatenate((image.astype(np.uint8), inpaint)))
-    cv2.waitKey()
diff --git a/spaces/oliver2023/chatgpt-on-wechat/lib/itchat/config.py b/spaces/oliver2023/chatgpt-on-wechat/lib/itchat/config.py
deleted file mode 100644
index 2ac6328dae8740e55bb1421f1c3952a36e9d0fee..0000000000000000000000000000000000000000
--- a/spaces/oliver2023/chatgpt-on-wechat/lib/itchat/config.py
+++ /dev/null
@@ -1,17 +0,0 @@
-import os, platform
-
-VERSION = '1.5.0.dev'
-
-# use this envrionment to initialize the async & sync componment
-ASYNC_COMPONENTS = os.environ.get('ITCHAT_UOS_ASYNC', False)
-
-BASE_URL = 'https://login.weixin.qq.com'
-OS = platform.system() # Windows, Linux, Darwin
-DIR = os.getcwd()
-DEFAULT_QR = 'QR.png'
-TIMEOUT = (10, 60)
-
-USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.71 Safari/537.36'
-
-UOS_PATCH_CLIENT_VERSION = '2.0.0'
-UOS_PATCH_EXTSPAM = 'Go8FCIkFEokFCggwMDAwMDAwMRAGGvAESySibk50w5Wb3uTl2c2h64jVVrV7gNs06GFlWplHQbY/5FfiO++1yH4ykCyNPWKXmco+wfQzK5R98D3so7rJ5LmGFvBLjGceleySrc3SOf2Pc1gVehzJgODeS0lDL3/I/0S2SSE98YgKleq6Uqx6ndTy9yaL9qFxJL7eiA/R3SEfTaW1SBoSITIu+EEkXff+Pv8NHOk7N57rcGk1w0ZzRrQDkXTOXFN2iHYIzAAZPIOY45Lsh+A4slpgnDiaOvRtlQYCt97nmPLuTipOJ8Qc5pM7ZsOsAPPrCQL7nK0I7aPrFDF0q4ziUUKettzW8MrAaiVfmbD1/VkmLNVqqZVvBCtRblXb5FHmtS8FxnqCzYP4WFvz3T0TcrOqwLX1M/DQvcHaGGw0B0y4bZMs7lVScGBFxMj3vbFi2SRKbKhaitxHfYHAOAa0X7/MSS0RNAjdwoyGHeOepXOKY+h3iHeqCvgOH6LOifdHf/1aaZNwSkGotYnYScW8Yx63LnSwba7+hESrtPa/huRmB9KWvMCKbDThL/nne14hnL277EDCSocPu3rOSYjuB9gKSOdVmWsj9Dxb/iZIe+S6AiG29Esm+/eUacSba0k8wn5HhHg9d4tIcixrxveflc8vi2/wNQGVFNsGO6tB5WF0xf/plngOvQ1/ivGV/C1Qpdhzznh0ExAVJ6dwzNg7qIEBaw+BzTJTUuRcPk92Sn6QDn2Pu3mpONaEumacjW4w6ipPnPw+g2TfywJjeEcpSZaP4Q3YV5HG8D6UjWA4GSkBKculWpdCMadx0usMomsSS/74QgpYqcPkmamB4nVv1JxczYITIqItIKjD35IGKAUwAA=='
diff --git a/spaces/omi0k/LoRA-DreamBooth-Training-UI/app.py b/spaces/omi0k/LoRA-DreamBooth-Training-UI/app.py
deleted file mode 100644
index 1b47590d28504c5832a3fbb2fcd4f5ef121cf7d8..0000000000000000000000000000000000000000
--- a/spaces/omi0k/LoRA-DreamBooth-Training-UI/app.py
+++ /dev/null
@@ -1,76 +0,0 @@
-#!/usr/bin/env python
-
-from __future__ import annotations
-
-import os
-
-import gradio as gr
-import torch
-
-from app_inference import create_inference_demo
-from app_training import create_training_demo
-from app_upload import create_upload_demo
-from inference import InferencePipeline
-from trainer import Trainer
-
-TITLE = '# LoRA DreamBooth Training UI'
-
-ORIGINAL_SPACE_ID = 'lora-library/LoRA-DreamBooth-Training-UI'
-SPACE_ID = os.getenv('SPACE_ID', ORIGINAL_SPACE_ID)
-SHARED_UI_WARNING = f'''# Attention - This Space doesn't work in this shared UI. You can duplicate and use it with a paid private T4 GPU.
-
-<center><a class="duplicate-button" style="display:inline-block" target="_blank" href="https://huggingface.co/spaces/{SPACE_ID}?duplicate=true"><img src="https://img.shields.io/badge/-Duplicate%20Space-blue?labelColor=white&style=flat&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAP5JREFUOE+lk7FqAkEURY+ltunEgFXS2sZGIbXfEPdLlnxJyDdYB62sbbUKpLbVNhyYFzbrrA74YJlh9r079973psed0cvUD4A+4HoCjsA85X0Dfn/RBLBgBDxnQPfAEJgBY+A9gALA4tcbamSzS4xq4FOQAJgCDwV2CPKV8tZAJcAjMMkUe1vX+U+SMhfAJEHasQIWmXNN3abzDwHUrgcRGmYcgKe0bxrblHEB4E/pndMazNpSZGcsZdBlYJcEL9Afo75molJyM2FxmPgmgPqlWNLGfwZGG6UiyEvLzHYDmoPkDDiNm9JR9uboiONcBXrpY1qmgs21x1QwyZcpvxt9NS09PlsPAAAAAElFTkSuQmCC&logoWidth=14" alt="Duplicate Space"></a></center>
-'''
-
-if os.getenv('SYSTEM') == 'spaces' and SPACE_ID != ORIGINAL_SPACE_ID:
-    SETTINGS = f'<a href="https://huggingface.co/spaces/{SPACE_ID}/settings">Settings</a>'
-else:
-    SETTINGS = 'Settings'
-CUDA_NOT_AVAILABLE_WARNING = f'''# Attention - Running on CPU.
-<center>
-You can assign a GPU in the {SETTINGS} tab if you are running this on HF Spaces.
-"T4 small" is sufficient to run this demo.
-</center>
-'''
-
-HF_TOKEN_NOT_SPECIFIED_WARNING = f'''# Attention - The environment variable `HF_TOKEN` is not specified. Please specify your Hugging Face token with write permission as the value of it.
-<center>
-You can check and create your Hugging Face tokens <a href="https://huggingface.co/settings/tokens" target="_blank">here</a>.
-You can specify environment variables in the "Repository secrets" section of the {SETTINGS} tab.
-</center>
-'''
-
-HF_TOKEN = os.getenv('HF_TOKEN')
-
-
-def show_warning(warning_text: str) -> gr.Blocks:
-    with gr.Blocks() as demo:
-        with gr.Box():
-            gr.Markdown(warning_text)
-    return demo
-
-
-pipe = InferencePipeline(HF_TOKEN)
-trainer = Trainer(HF_TOKEN)
-
-with gr.Blocks(css='style.css') as demo:
-    if os.getenv('IS_SHARED_UI'):
-        show_warning(SHARED_UI_WARNING)
-    if not torch.cuda.is_available():
-        show_warning(CUDA_NOT_AVAILABLE_WARNING)
-    if not HF_TOKEN:
-        show_warning(HF_TOKEN_NOT_SPECIFIED_WARNING)
-
-    gr.Markdown(TITLE)
-    with gr.Tabs():
-        with gr.TabItem('Train'):
-            create_training_demo(trainer, pipe)
-        with gr.TabItem('Test'):
-            create_inference_demo(pipe, HF_TOKEN)
-        with gr.TabItem('Upload'):
-            gr.Markdown('''
-            - You can use this tab to upload models later if you choose not to upload models in training time or if upload in training time failed.
-            ''')
-            create_upload_demo(HF_TOKEN)
-
-demo.queue(max_size=1).launch(share=False)
diff --git a/spaces/omi0k/LoRA-DreamBooth-Training-UI/uploader.py b/spaces/omi0k/LoRA-DreamBooth-Training-UI/uploader.py
deleted file mode 100644
index 0ce697f0d47325a4d73f92c13304ae5f51df794a..0000000000000000000000000000000000000000
--- a/spaces/omi0k/LoRA-DreamBooth-Training-UI/uploader.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from __future__ import annotations
-
-from huggingface_hub import HfApi
-
-
-class Uploader:
-    def __init__(self, hf_token: str | None):
-        self.api = HfApi(token=hf_token)
-
-    def get_username(self) -> str:
-        return self.api.whoami()['name']
-
-    def upload(self,
-               folder_path: str,
-               repo_name: str,
-               organization: str = '',
-               repo_type: str = 'model',
-               private: bool = True,
-               delete_existing_repo: bool = False) -> str:
-        if not folder_path:
-            raise ValueError
-        if not repo_name:
-            raise ValueError
-        if not organization:
-            organization = self.get_username()
-        repo_id = f'{organization}/{repo_name}'
-        if delete_existing_repo:
-            try:
-                self.api.delete_repo(repo_id, repo_type=repo_type)
-            except Exception:
-                pass
-        try:
-            self.api.create_repo(repo_id, repo_type=repo_type, private=private)
-            self.api.upload_folder(repo_id=repo_id,
-                                   folder_path=folder_path,
-                                   path_in_repo='.',
-                                   repo_type=repo_type)
-            url = f'https://huggingface.co/{repo_id}'
-            message = f'Your model was successfully uploaded to <a href="{url}" target="_blank">{url}</a>.'
-        except Exception as e:
-            message = str(e)
-        return message
diff --git a/spaces/onereal/rvc-models-convertvoice/infer_pack/commons.py b/spaces/onereal/rvc-models-convertvoice/infer_pack/commons.py
deleted file mode 100644
index 54470986f37825b35d90d7efa7437d1c26b87215..0000000000000000000000000000000000000000
--- a/spaces/onereal/rvc-models-convertvoice/infer_pack/commons.py
+++ /dev/null
@@ -1,166 +0,0 @@
-import math
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-
-def init_weights(m, mean=0.0, std=0.01):
-    classname = m.__class__.__name__
-    if classname.find("Conv") != -1:
-        m.weight.data.normal_(mean, std)
-
-
-def get_padding(kernel_size, dilation=1):
-    return int((kernel_size * dilation - dilation) / 2)
-
-
-def convert_pad_shape(pad_shape):
-    l = pad_shape[::-1]
-    pad_shape = [item for sublist in l for item in sublist]
-    return pad_shape
-
-
-def kl_divergence(m_p, logs_p, m_q, logs_q):
-    """KL(P||Q)"""
-    kl = (logs_q - logs_p) - 0.5
-    kl += (
-        0.5 * (torch.exp(2.0 * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2.0 * logs_q)
-    )
-    return kl
-
-
-def rand_gumbel(shape):
-    """Sample from the Gumbel distribution, protect from overflows."""
-    uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
-    return -torch.log(-torch.log(uniform_samples))
-
-
-def rand_gumbel_like(x):
-    g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
-    return g
-
-
-def slice_segments(x, ids_str, segment_size=4):
-    ret = torch.zeros_like(x[:, :, :segment_size])
-    for i in range(x.size(0)):
-        idx_str = ids_str[i]
-        idx_end = idx_str + segment_size
-        ret[i] = x[i, :, idx_str:idx_end]
-    return ret
-
-
-def slice_segments2(x, ids_str, segment_size=4):
-    ret = torch.zeros_like(x[:, :segment_size])
-    for i in range(x.size(0)):
-        idx_str = ids_str[i]
-        idx_end = idx_str + segment_size
-        ret[i] = x[i, idx_str:idx_end]
-    return ret
-
-
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
-    b, d, t = x.size()
-    if x_lengths is None:
-        x_lengths = t
-    ids_str_max = x_lengths - segment_size + 1
-    ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
-    ret = slice_segments(x, ids_str, segment_size)
-    return ret, ids_str
-
-
-def get_timing_signal_1d(length, channels, min_timescale=1.0, max_timescale=1.0e4):
-    position = torch.arange(length, dtype=torch.float)
-    num_timescales = channels // 2
-    log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / (
-        num_timescales - 1
-    )
-    inv_timescales = min_timescale * torch.exp(
-        torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment
-    )
-    scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
-    signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
-    signal = F.pad(signal, [0, 0, 0, channels % 2])
-    signal = signal.view(1, channels, length)
-    return signal
-
-
-def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
-    b, channels, length = x.size()
-    signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-    return x + signal.to(dtype=x.dtype, device=x.device)
-
-
-def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
-    b, channels, length = x.size()
-    signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-    return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
-
-
-def subsequent_mask(length):
-    mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
-    return mask
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-    n_channels_int = n_channels[0]
-    in_act = input_a + input_b
-    t_act = torch.tanh(in_act[:, :n_channels_int, :])
-    s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-    acts = t_act * s_act
-    return acts
-
-
-def convert_pad_shape(pad_shape):
-    l = pad_shape[::-1]
-    pad_shape = [item for sublist in l for item in sublist]
-    return pad_shape
-
-
-def shift_1d(x):
-    x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
-    return x
-
-
-def sequence_mask(length, max_length=None):
-    if max_length is None:
-        max_length = length.max()
-    x = torch.arange(max_length, dtype=length.dtype, device=length.device)
-    return x.unsqueeze(0) < length.unsqueeze(1)
-
-
-def generate_path(duration, mask):
-    """
-    duration: [b, 1, t_x]
-    mask: [b, 1, t_y, t_x]
-    """
-    device = duration.device
-
-    b, _, t_y, t_x = mask.shape
-    cum_duration = torch.cumsum(duration, -1)
-
-    cum_duration_flat = cum_duration.view(b * t_x)
-    path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
-    path = path.view(b, t_x, t_y)
-    path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
-    path = path.unsqueeze(1).transpose(2, 3) * mask
-    return path
-
-
-def clip_grad_value_(parameters, clip_value, norm_type=2):
-    if isinstance(parameters, torch.Tensor):
-        parameters = [parameters]
-    parameters = list(filter(lambda p: p.grad is not None, parameters))
-    norm_type = float(norm_type)
-    if clip_value is not None:
-        clip_value = float(clip_value)
-
-    total_norm = 0
-    for p in parameters:
-        param_norm = p.grad.data.norm(norm_type)
-        total_norm += param_norm.item() ** norm_type
-        if clip_value is not None:
-            p.grad.data.clamp_(min=-clip_value, max=clip_value)
-    total_norm = total_norm ** (1.0 / norm_type)
-    return total_norm
diff --git a/spaces/oschan77/virtualoscar/README.md b/spaces/oschan77/virtualoscar/README.md
deleted file mode 100644
index e4d48476a1eb2c9f20b98e9690e8402093310783..0000000000000000000000000000000000000000
--- a/spaces/oschan77/virtualoscar/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: VirtualOscar
-emoji: 📉
-colorFrom: pink
-colorTo: pink
-sdk: gradio
-sdk_version: 3.33.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/p1atdev/AdverseCleaner/main.py b/spaces/p1atdev/AdverseCleaner/main.py
deleted file mode 100644
index 52a458cef1b7ba9f3981887f8ba3e485f0232a49..0000000000000000000000000000000000000000
--- a/spaces/p1atdev/AdverseCleaner/main.py
+++ /dev/null
@@ -1,134 +0,0 @@
-import numpy as np
-import cv2
-from PIL import Image
-from cv2.ximgproc import guidedFilter
-import gradio as gr
-
-
-def clean_image(
-    input_image: Image,
-    diameter: float = 5,
-    sigma_color: float = 8,
-    sigma_space: float = 8,
-    radius: float = 4,
-    eps: float = 16,
-) -> Image:
-    img = np.array(input_image).astype(np.float32)
-    y = img.copy()
-
-    for _ in range(64):
-        y = cv2.bilateralFilter(y, diameter, sigma_color, sigma_space)
-
-    for _ in range(4):
-        y = guidedFilter(img, y, radius, eps)
-
-    output_image = Image.fromarray(y.clip(0, 255).astype(np.uint8))
-    return output_image
-
-
-def example(_image):
-    pass
-
-
-def send_to_input(output):
-    return output
-
-
-def ui():
-    with gr.Blocks() as app:
-        with gr.Row():
-            with gr.Column():
-                input_image = gr.Image(type="pil", label="Input Image")
-                start_btn = gr.Button(value="Start", variant="primary")
-
-                with gr.Accordion("Advanced Config", open=False):
-                    # ref: https://github.com/gogodr/AdverseCleanerExtension
-                    gr.Markdown("#### Bilateral Filter")
-                    diameter_slider = gr.Slider(
-                        minimum=1,
-                        maximum=30,
-                        step=1,
-                        value=5,
-                        label="Diameter (default = 5)",
-                        interactive=True,
-                    )
-                    sigma_color_slider = gr.Slider(
-                        minimum=1,
-                        maximum=30,
-                        step=1,
-                        value=8,
-                        label="SigmaColor (default = 8)",
-                        interactive=True,
-                    )
-                    sigma_space_slider = gr.Slider(
-                        minimum=1,
-                        maximum=30,
-                        step=1,
-                        value=8,
-                        label="SigmaSpace (default = 8)",
-                        interactive=True,
-                    )
-
-                    gr.Markdown("#### Guided Filter")
-                    radius_slider = gr.Slider(
-                        minimum=1,
-                        maximum=30,
-                        step=1,
-                        value=4,
-                        label="Radius (default = 4)",
-                        interactive=True,
-                    )
-                    eps_slider = gr.Slider(
-                        minimum=1,
-                        maximum=30,
-                        step=1,
-                        value=16,
-                        label="Accuracy (default = 16)",
-                        interactive=True,
-                    )
-
-                gr.Examples(
-                    examples=[
-                        ["./examples/sample1.jpg"],
-                        ["./examples/sample2.jpg"],
-                        ["./examples/sample3.jpg"],
-                    ],
-                    inputs=[
-                        input_image,
-                    ],
-                    outputs=[],
-                    fn=example,
-                    cache_examples=True,
-                )
-
-            with gr.Column():
-                output_image = gr.Image(
-                    type="pil", label="Output Image", interactive=False
-                )
-                send_to_input_btn = gr.Button(value="Use as input", variant="secondary")
-
-        gr.Markdown(
-            "The lllyasviel's original repo is [here](https://github.com/lllyasviel/AdverseCleaner/tree/main)."
-        )
-
-        start_btn.click(
-            fn=clean_image,
-            inputs=[
-                input_image,
-                diameter_slider,
-                sigma_color_slider,
-                sigma_space_slider,
-                radius_slider,
-                eps_slider,
-            ],
-            outputs=[output_image],
-        )
-        send_to_input_btn.click(
-            fn=send_to_input, inputs=[output_image], outputs=[input_image]
-        )
-
-    app.launch()
-
-
-if __name__ == "__main__":
-    ui()
diff --git a/spaces/pablodawson/ldm3d-inpainting/diffuserslocal/src/diffusers/models/activations.py b/spaces/pablodawson/ldm3d-inpainting/diffuserslocal/src/diffusers/models/activations.py
deleted file mode 100644
index 04c978403f419e3b0472d5a3d4caf62ca4f60585..0000000000000000000000000000000000000000
--- a/spaces/pablodawson/ldm3d-inpainting/diffuserslocal/src/diffusers/models/activations.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from torch import nn
-
-
-def get_activation(act_fn):
-    if act_fn in ["swish", "silu"]:
-        return nn.SiLU()
-    elif act_fn == "mish":
-        return nn.Mish()
-    elif act_fn == "gelu":
-        return nn.GELU()
-    elif act_fn == "relu":
-        return nn.ReLU()
-    else:
-        raise ValueError(f"Unsupported activation function: {act_fn}")
diff --git a/spaces/paulokewunmi/jumia_product_search/image_search_engine/metadata/__init__.py b/spaces/paulokewunmi/jumia_product_search/image_search_engine/metadata/__init__.py
deleted file mode 100644
index 4f427c9eec094d56ff2ee2e35501b284fbd05697..0000000000000000000000000000000000000000
--- a/spaces/paulokewunmi/jumia_product_search/image_search_engine/metadata/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from . import jumia_3650, shared
diff --git a/spaces/peteralexandercharles/wav2vec2-uk-demo/app.py b/spaces/peteralexandercharles/wav2vec2-uk-demo/app.py
deleted file mode 100644
index d13d39d9c5382bdc8447d24f1330dee3f566a5b1..0000000000000000000000000000000000000000
--- a/spaces/peteralexandercharles/wav2vec2-uk-demo/app.py
+++ /dev/null
@@ -1,93 +0,0 @@
-import gradio as gr
-from transformers import Wav2Vec2CTCTokenizer, Wav2Vec2ForCTC, Wav2Vec2ProcessorWithLM
-import torch
-import torchaudio
-
-model_name = "Yehor/wav2vec2-xls-r-300m-uk-with-small-lm"
-
-tokenizer = Wav2Vec2CTCTokenizer.from_pretrained(model_name)
-processor = Wav2Vec2ProcessorWithLM.from_pretrained(model_name)
-model = Wav2Vec2ForCTC.from_pretrained(model_name)
-model.to("cpu")
-
-
-# define function to read in sound file
-def speech_file_to_array_fn(path, max_seconds=10):
-    batch = {"file": path}
-    speech_array, sampling_rate = torchaudio.load(batch["file"])
-    if sampling_rate != 16000:
-        transform = torchaudio.transforms.Resample(
-            orig_freq=sampling_rate, new_freq=16000
-        )
-        speech_array = transform(speech_array)
-    speech_array = speech_array[0]
-    if max_seconds > 0:
-        speech_array = speech_array[: max_seconds * 16000]
-    batch["speech"] = speech_array.numpy()
-    batch["sampling_rate"] = 16000
-    return batch
-
-
-# tokenize
-def inference(audio):
-    # read in sound file
-    # load dummy dataset and read soundfiles
-    sp = speech_file_to_array_fn(audio.name)
-
-    sample_rate = 16000
-    # stride_length_s is a tuple of the left and right stride length.
-    # With only 1 number, both sides get the same stride, by default
-    # the stride_length on one side is 1/6th of the chunk_length_s
-    input_values = processor(
-        sp["speech"],
-        sample_rate=sample_rate,
-        chunk_length_s=10,
-        stride_length_s=(4, 2),
-        return_tensors="pt",
-    ).input_values
-
-    with torch.no_grad():
-        logits = model(input_values).logits
-
-    pred_ids = torch.argmax(logits, axis=-1).cpu().tolist()
-    prediction = tokenizer.decode(pred_ids[0], output_word_offsets=True)
-
-    time_offset = 320 / sample_rate
-
-    total_prediction = []
-    words = []
-    for item in prediction.word_offsets:
-        r = item
-
-        s = round(r['start_offset'] * time_offset, 2)
-        e = round(r['end_offset'] * time_offset, 2)
-
-        total_prediction.append(f"{s} - {e}: {r['word']}")
-        words.append(r['word'])
-
-    print(prediction[0])
-
-    return "\n".join(total_prediction) + "\n\n" + ' '.join(words)
-
-
-inputs = gr.inputs.Audio(label="Input Audio", type="file")
-outputs = gr.outputs.Textbox(label="Output Text")
-title = model_name
-description = f"Gradio demo for a {model_name}. To use it, simply upload your audio, or click one of the examples to load them. Read more at the links below. Currently supports .wav 16_000hz files"
-article = "<p style='text-align: center'><a href='https://github.com/egorsmkv/wav2vec2-uk-demo' target='_blank'> Github repo</a> | <a href='<HF Space link>' target='_blank'>Pretrained model</a> | Made with help from <a href='https://github.com/robinhad' target='_blank'>@robinhad</a></p>"
-examples = [
-    ["long_1.wav"],
-    ["mer_lviv_interview.wav"],
-    ["short_1.wav"],
-    ["tsn_2.wav"],
-    ["tsn.wav"],
-]
-gr.Interface(
-    inference,
-    inputs,
-    outputs,
-    title=title,
-    description=description,
-    article=article,
-    examples=examples,
-).launch()
diff --git a/spaces/pirahansiah/ComputerVision/src/yolo.py b/spaces/pirahansiah/ComputerVision/src/yolo.py
deleted file mode 100644
index 0cea8caeaa7dcead3a7eb209d6e91d90bbabead8..0000000000000000000000000000000000000000
--- a/spaces/pirahansiah/ComputerVision/src/yolo.py
+++ /dev/null
@@ -1,57 +0,0 @@
-import cv2
-import numpy as np
-import gradio as gr
-from ultralytics import YOLO
-def draw_boxes(image, boxes):
-    for box in boxes:        
-        x1, y1, x2, y2, name, prob = box
-        cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
-        cv2.putText(image, f"{name} {prob:.2f}", (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 1.9, (255,55,0), 2)  
-    return image
-def detect_objects_on_image(buf):    
-    model = YOLO("files/yolov8n.pt")      
-    results = model.predict(buf)
-    result = results[0]
-    output = []
-    for box in result.boxes:
-        x1, y1, x2, y2 = [
-            round(x) for x in box.xyxy[0].tolist()
-        ]
-        class_id = box.cls[0].item()
-        prob = round(box.conf[0].item(), 2)
-        output.append([
-            x1, y1, x2, y2, result.names[class_id], prob
-        ])
-    return output
-
-path  = [['files/a.png'],['files/image_0.png'],['files/huggingface.png']]
-inputs = [
-gr.inputs.Image(type="filepath", label="Input Image"),
-gr.inputs.Radio(label="YOLO Methods", 
-                choices=[                         
-                        "v8"                        
-                    ]),  
-   
-]
-outputs = [   
-gr.outputs.Image(type="numpy", label="Output YOLO Image")     
-]
-def process_image(input_image, radio_choice,slider_val):    
-    img = cv2.imread(input_image)  
-    img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB) 
-    boxes=detect_objects_on_image(img)
-    img_with_boxes = draw_boxes(img, boxes)                  
-    return img_with_boxes
-def on_change(radio_choice):
-    outputs[0].update(process_image(
-        inputs[0].value,          
-        radio_choice)
-    )
-yolo = gr.Interface(
-    fn=process_image,
-    inputs=inputs,
-    outputs=outputs, 
-    on_change=on_change,
-    examples=path,
-    title="YOLO: Computer Vision and Deep Learning by Farshid PirahanSiah",    
-    )
\ No newline at end of file
diff --git a/spaces/pritamdeka/pubmed-abstract-retriever/nltkmodule.py b/spaces/pritamdeka/pubmed-abstract-retriever/nltkmodule.py
deleted file mode 100644
index 156e12862eada3d3dad70601d930d67c19ad1dd1..0000000000000000000000000000000000000000
--- a/spaces/pritamdeka/pubmed-abstract-retriever/nltkmodule.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import nltk
-nltk.download('wordnet')
-nltk.download('punkt')
-nltk.download('stopwords')
-nltk.download('averaged_perceptron_tagger')
-nltk.download('maxent_ne_chunker')
-nltk.download('words')
-nltk.download('brown')
\ No newline at end of file
diff --git a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/fontTools/misc/configTools.py b/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/fontTools/misc/configTools.py
deleted file mode 100644
index 38bbada24a19b767756407313d41011db7e1719d..0000000000000000000000000000000000000000
--- a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/fontTools/misc/configTools.py
+++ /dev/null
@@ -1,348 +0,0 @@
-"""
-Code of the config system; not related to fontTools or fonts in particular.
-
-The options that are specific to fontTools are in :mod:`fontTools.config`.
-
-To create your own config system, you need to create an instance of
-:class:`Options`, and a subclass of :class:`AbstractConfig` with its
-``options`` class variable set to your instance of Options.
-
-"""
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass
-from typing import (
-    Any,
-    Callable,
-    ClassVar,
-    Dict,
-    Iterable,
-    Mapping,
-    MutableMapping,
-    Optional,
-    Set,
-    Union,
-)
-
-
-log = logging.getLogger(__name__)
-
-__all__ = [
-    "AbstractConfig",
-    "ConfigAlreadyRegisteredError",
-    "ConfigError",
-    "ConfigUnknownOptionError",
-    "ConfigValueParsingError",
-    "ConfigValueValidationError",
-    "Option",
-    "Options",
-]
-
-
-class ConfigError(Exception):
-    """Base exception for the config module."""
-
-
-class ConfigAlreadyRegisteredError(ConfigError):
-    """Raised when a module tries to register a configuration option that
-    already exists.
-
-    Should not be raised too much really, only when developing new fontTools
-    modules.
-    """
-
-    def __init__(self, name):
-        super().__init__(f"Config option {name} is already registered.")
-
-
-class ConfigValueParsingError(ConfigError):
-    """Raised when a configuration value cannot be parsed."""
-
-    def __init__(self, name, value):
-        super().__init__(
-            f"Config option {name}: value cannot be parsed (given {repr(value)})"
-        )
-
-
-class ConfigValueValidationError(ConfigError):
-    """Raised when a configuration value cannot be validated."""
-
-    def __init__(self, name, value):
-        super().__init__(
-            f"Config option {name}: value is invalid (given {repr(value)})"
-        )
-
-
-class ConfigUnknownOptionError(ConfigError):
-    """Raised when a configuration option is unknown."""
-
-    def __init__(self, option_or_name):
-        name = (
-            f"'{option_or_name.name}' (id={id(option_or_name)})>"
-            if isinstance(option_or_name, Option)
-            else f"'{option_or_name}'"
-        )
-        super().__init__(f"Config option {name} is unknown")
-
-
-# eq=False because Options are unique, not fungible objects
-@dataclass(frozen=True, eq=False)
-class Option:
-    name: str
-    """Unique name identifying the option (e.g. package.module:MY_OPTION)."""
-    help: str
-    """Help text for this option."""
-    default: Any
-    """Default value for this option."""
-    parse: Callable[[str], Any]
-    """Turn input (e.g. string) into proper type. Only when reading from file."""
-    validate: Optional[Callable[[Any], bool]] = None
-    """Return true if the given value is an acceptable value."""
-
-    @staticmethod
-    def parse_optional_bool(v: str) -> Optional[bool]:
-        s = str(v).lower()
-        if s in {"0", "no", "false"}:
-            return False
-        if s in {"1", "yes", "true"}:
-            return True
-        if s in {"auto", "none"}:
-            return None
-        raise ValueError("invalid optional bool: {v!r}")
-
-    @staticmethod
-    def validate_optional_bool(v: Any) -> bool:
-        return v is None or isinstance(v, bool)
-
-
-class Options(Mapping):
-    """Registry of available options for a given config system.
-
-    Define new options using the :meth:`register()` method.
-
-    Access existing options using the Mapping interface.
-    """
-
-    __options: Dict[str, Option]
-
-    def __init__(self, other: "Options" = None) -> None:
-        self.__options = {}
-        if other is not None:
-            for option in other.values():
-                self.register_option(option)
-
-    def register(
-        self,
-        name: str,
-        help: str,
-        default: Any,
-        parse: Callable[[str], Any],
-        validate: Optional[Callable[[Any], bool]] = None,
-    ) -> Option:
-        """Create and register a new option."""
-        return self.register_option(Option(name, help, default, parse, validate))
-
-    def register_option(self, option: Option) -> Option:
-        """Register a new option."""
-        name = option.name
-        if name in self.__options:
-            raise ConfigAlreadyRegisteredError(name)
-        self.__options[name] = option
-        return option
-
-    def is_registered(self, option: Option) -> bool:
-        """Return True if the same option object is already registered."""
-        return self.__options.get(option.name) is option
-
-    def __getitem__(self, key: str) -> Option:
-        return self.__options.__getitem__(key)
-
-    def __iter__(self) -> Iterator[str]:
-        return self.__options.__iter__()
-
-    def __len__(self) -> int:
-        return self.__options.__len__()
-
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}({{\n"
-            + "".join(
-                f"    {k!r}: Option(default={v.default!r}, ...),\n"
-                for k, v in self.__options.items()
-            )
-            + "})"
-        )
-
-
-_USE_GLOBAL_DEFAULT = object()
-
-
-class AbstractConfig(MutableMapping):
-    """
-    Create a set of config values, optionally pre-filled with values from
-    the given dictionary or pre-existing config object.
-
-    The class implements the MutableMapping protocol keyed by option name (`str`).
-    For convenience its methods accept either Option or str as the key parameter.
-
-    .. seealso:: :meth:`set()`
-
-    This config class is abstract because it needs its ``options`` class
-    var to be set to an instance of :class:`Options` before it can be
-    instanciated and used.
-
-    .. code:: python
-
-        class MyConfig(AbstractConfig):
-            options = Options()
-
-        MyConfig.register_option( "test:option_name", "This is an option", 0, int, lambda v: isinstance(v, int))
-
-        cfg = MyConfig({"test:option_name": 10})
-
-    """
-
-    options: ClassVar[Options]
-
-    @classmethod
-    def register_option(
-        cls,
-        name: str,
-        help: str,
-        default: Any,
-        parse: Callable[[str], Any],
-        validate: Optional[Callable[[Any], bool]] = None,
-    ) -> Option:
-        """Register an available option in this config system."""
-        return cls.options.register(
-            name, help=help, default=default, parse=parse, validate=validate
-        )
-
-    _values: Dict[str, Any]
-
-    def __init__(
-        self,
-        values: Union[AbstractConfig, Dict[Union[Option, str], Any]] = {},
-        parse_values: bool = False,
-        skip_unknown: bool = False,
-    ):
-        self._values = {}
-        values_dict = values._values if isinstance(values, AbstractConfig) else values
-        for name, value in values_dict.items():
-            self.set(name, value, parse_values, skip_unknown)
-
-    def _resolve_option(self, option_or_name: Union[Option, str]) -> Option:
-        if isinstance(option_or_name, Option):
-            option = option_or_name
-            if not self.options.is_registered(option):
-                raise ConfigUnknownOptionError(option)
-            return option
-        elif isinstance(option_or_name, str):
-            name = option_or_name
-            try:
-                return self.options[name]
-            except KeyError:
-                raise ConfigUnknownOptionError(name)
-        else:
-            raise TypeError(
-                "expected Option or str, found "
-                f"{type(option_or_name).__name__}: {option_or_name!r}"
-            )
-
-    def set(
-        self,
-        option_or_name: Union[Option, str],
-        value: Any,
-        parse_values: bool = False,
-        skip_unknown: bool = False,
-    ):
-        """Set the value of an option.
-
-        Args:
-            * `option_or_name`: an `Option` object or its name (`str`).
-            * `value`: the value to be assigned to given option.
-            * `parse_values`: parse the configuration value from a string into
-                its proper type, as per its `Option` object. The default
-                behavior is to raise `ConfigValueValidationError` when the value
-                is not of the right type. Useful when reading options from a
-                file type that doesn't support as many types as Python.
-            * `skip_unknown`: skip unknown configuration options. The default
-                behaviour is to raise `ConfigUnknownOptionError`. Useful when
-                reading options from a configuration file that has extra entries
-                (e.g. for a later version of fontTools)
-        """
-        try:
-            option = self._resolve_option(option_or_name)
-        except ConfigUnknownOptionError as e:
-            if skip_unknown:
-                log.debug(str(e))
-                return
-            raise
-
-        # Can be useful if the values come from a source that doesn't have
-        # strict typing (.ini file? Terminal input?)
-        if parse_values:
-            try:
-                value = option.parse(value)
-            except Exception as e:
-                raise ConfigValueParsingError(option.name, value) from e
-
-        if option.validate is not None and not option.validate(value):
-            raise ConfigValueValidationError(option.name, value)
-
-        self._values[option.name] = value
-
-    def get(
-        self, option_or_name: Union[Option, str], default: Any = _USE_GLOBAL_DEFAULT
-    ) -> Any:
-        """
-        Get the value of an option. The value which is returned is the first
-        provided among:
-
-        1. a user-provided value in the options's ``self._values`` dict
-        2. a caller-provided default value to this method call
-        3. the global default for the option provided in ``fontTools.config``
-
-        This is to provide the ability to migrate progressively from config
-        options passed as arguments to fontTools APIs to config options read
-        from the current TTFont, e.g.
-
-        .. code:: python
-
-            def fontToolsAPI(font, some_option):
-                value = font.cfg.get("someLib.module:SOME_OPTION", some_option)
-                # use value
-
-        That way, the function will work the same for users of the API that
-        still pass the option to the function call, but will favour the new
-        config mechanism if the given font specifies a value for that option.
-        """
-        option = self._resolve_option(option_or_name)
-        if option.name in self._values:
-            return self._values[option.name]
-        if default is not _USE_GLOBAL_DEFAULT:
-            return default
-        return option.default
-
-    def copy(self):
-        return self.__class__(self._values)
-
-    def __getitem__(self, option_or_name: Union[Option, str]) -> Any:
-        return self.get(option_or_name)
-
-    def __setitem__(self, option_or_name: Union[Option, str], value: Any) -> None:
-        return self.set(option_or_name, value)
-
-    def __delitem__(self, option_or_name: Union[Option, str]) -> None:
-        option = self._resolve_option(option_or_name)
-        del self._values[option.name]
-
-    def __iter__(self) -> Iterable[str]:
-        return self._values.__iter__()
-
-    def __len__(self) -> int:
-        return len(self._values)
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}({repr(self._values)})"
diff --git a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/fontTools/ttLib/tables/_a_v_a_r.py b/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/fontTools/ttLib/tables/_a_v_a_r.py
deleted file mode 100644
index 39039cf73a5346db144f39bd8c046a76bd52af31..0000000000000000000000000000000000000000
--- a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/fontTools/ttLib/tables/_a_v_a_r.py
+++ /dev/null
@@ -1,138 +0,0 @@
-from fontTools.misc import sstruct
-from fontTools.misc.fixedTools import (
-    fixedToFloat as fi2fl,
-    floatToFixed as fl2fi,
-    floatToFixedToStr as fl2str,
-    strToFixedToFloat as str2fl,
-)
-from fontTools.misc.textTools import bytesjoin, safeEval
-from fontTools.ttLib import TTLibError
-from . import DefaultTable
-from . import otTables
-import struct
-import logging
-
-
-log = logging.getLogger(__name__)
-
-from .otBase import BaseTTXConverter
-
-
-class table__a_v_a_r(BaseTTXConverter):
-    """Axis Variations Table
-
-    This class represents the ``avar`` table of a variable font. The object has one
-    substantive attribute, ``segments``, which maps axis tags to a segments dictionary::
-
-        >>> font["avar"].segments   # doctest: +SKIP
-        {'wght': {-1.0: -1.0,
-          0.0: 0.0,
-          0.125: 0.11444091796875,
-          0.25: 0.23492431640625,
-          0.5: 0.35540771484375,
-          0.625: 0.5,
-          0.75: 0.6566162109375,
-          0.875: 0.81927490234375,
-          1.0: 1.0},
-         'ital': {-1.0: -1.0, 0.0: 0.0, 1.0: 1.0}}
-
-    Notice that the segments dictionary is made up of normalized values. A valid
-    ``avar`` segment mapping must contain the entries ``-1.0: -1.0, 0.0: 0.0, 1.0: 1.0``.
-    fontTools does not enforce this, so it is your responsibility to ensure that
-    mappings are valid.
-    """
-
-    dependencies = ["fvar"]
-
-    def __init__(self, tag=None):
-        super().__init__(tag)
-        self.segments = {}
-
-    def compile(self, ttFont):
-        axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
-        if not hasattr(self, "table"):
-            self.table = otTables.avar()
-        if not hasattr(self.table, "Reserved"):
-            self.table.Reserved = 0
-        self.table.Version = (getattr(self, "majorVersion", 1) << 16) | getattr(
-            self, "minorVersion", 0
-        )
-        self.table.AxisCount = len(axisTags)
-        self.table.AxisSegmentMap = []
-        for axis in axisTags:
-            mappings = self.segments[axis]
-            segmentMap = otTables.AxisSegmentMap()
-            segmentMap.PositionMapCount = len(mappings)
-            segmentMap.AxisValueMap = []
-            for key, value in sorted(mappings.items()):
-                valueMap = otTables.AxisValueMap()
-                valueMap.FromCoordinate = key
-                valueMap.ToCoordinate = value
-                segmentMap.AxisValueMap.append(valueMap)
-            self.table.AxisSegmentMap.append(segmentMap)
-        return super().compile(ttFont)
-
-    def decompile(self, data, ttFont):
-        super().decompile(data, ttFont)
-        assert self.table.Version >= 0x00010000
-        self.majorVersion = self.table.Version >> 16
-        self.minorVersion = self.table.Version & 0xFFFF
-        axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
-        for axis in axisTags:
-            self.segments[axis] = {}
-        for axis, segmentMap in zip(axisTags, self.table.AxisSegmentMap):
-            segments = self.segments[axis] = {}
-            for segment in segmentMap.AxisValueMap:
-                segments[segment.FromCoordinate] = segment.ToCoordinate
-
-    def toXML(self, writer, ttFont):
-        writer.simpletag(
-            "version",
-            major=getattr(self, "majorVersion", 1),
-            minor=getattr(self, "minorVersion", 0),
-        )
-        writer.newline()
-        axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
-        for axis in axisTags:
-            writer.begintag("segment", axis=axis)
-            writer.newline()
-            for key, value in sorted(self.segments[axis].items()):
-                key = fl2str(key, 14)
-                value = fl2str(value, 14)
-                writer.simpletag("mapping", **{"from": key, "to": value})
-                writer.newline()
-            writer.endtag("segment")
-            writer.newline()
-        if getattr(self, "majorVersion", 1) >= 2:
-            if self.table.VarIdxMap:
-                self.table.VarIdxMap.toXML(writer, ttFont, name="VarIdxMap")
-            if self.table.VarStore:
-                self.table.VarStore.toXML(writer, ttFont)
-
-    def fromXML(self, name, attrs, content, ttFont):
-        if not hasattr(self, "table"):
-            self.table = otTables.avar()
-        if not hasattr(self.table, "Reserved"):
-            self.table.Reserved = 0
-        if name == "version":
-            self.majorVersion = safeEval(attrs["major"])
-            self.minorVersion = safeEval(attrs["minor"])
-            self.table.Version = (getattr(self, "majorVersion", 1) << 16) | getattr(
-                self, "minorVersion", 0
-            )
-        elif name == "segment":
-            axis = attrs["axis"]
-            segment = self.segments[axis] = {}
-            for element in content:
-                if isinstance(element, tuple):
-                    elementName, elementAttrs, _ = element
-                    if elementName == "mapping":
-                        fromValue = str2fl(elementAttrs["from"], 14)
-                        toValue = str2fl(elementAttrs["to"], 14)
-                        if fromValue in segment:
-                            log.warning(
-                                "duplicate entry for %s in axis '%s'", fromValue, axis
-                            )
-                        segment[fromValue] = toValue
-        else:
-            super().fromXML(name, attrs, content, ttFont)
diff --git a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/jsonschema/_keywords.py b/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/jsonschema/_keywords.py
deleted file mode 100644
index b3a0e3cc603627cc4714f672d3ac7ac0e893cbbd..0000000000000000000000000000000000000000
--- a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/jsonschema/_keywords.py
+++ /dev/null
@@ -1,440 +0,0 @@
-from fractions import Fraction
-import re
-
-from jsonschema._utils import (
-    ensure_list,
-    equal,
-    extras_msg,
-    find_additional_properties,
-    find_evaluated_item_indexes_by_schema,
-    find_evaluated_property_keys_by_schema,
-    unbool,
-    uniq,
-)
-from jsonschema.exceptions import FormatError, ValidationError
-
-
-def patternProperties(validator, patternProperties, instance, schema):
-    if not validator.is_type(instance, "object"):
-        return
-
-    for pattern, subschema in patternProperties.items():
-        for k, v in instance.items():
-            if re.search(pattern, k):
-                yield from validator.descend(
-                    v, subschema, path=k, schema_path=pattern,
-                )
-
-
-def propertyNames(validator, propertyNames, instance, schema):
-    if not validator.is_type(instance, "object"):
-        return
-
-    for property in instance:
-        yield from validator.descend(instance=property, schema=propertyNames)
-
-
-def additionalProperties(validator, aP, instance, schema):
-    if not validator.is_type(instance, "object"):
-        return
-
-    extras = set(find_additional_properties(instance, schema))
-
-    if validator.is_type(aP, "object"):
-        for extra in extras:
-            yield from validator.descend(instance[extra], aP, path=extra)
-    elif not aP and extras:
-        if "patternProperties" in schema:
-            verb = "does" if len(extras) == 1 else "do"
-            joined = ", ".join(repr(each) for each in sorted(extras))
-            patterns = ", ".join(
-                repr(each) for each in sorted(schema["patternProperties"])
-            )
-            error = f"{joined} {verb} not match any of the regexes: {patterns}"
-            yield ValidationError(error)
-        else:
-            error = "Additional properties are not allowed (%s %s unexpected)"
-            yield ValidationError(error % extras_msg(sorted(extras, key=str)))
-
-
-def items(validator, items, instance, schema):
-    if not validator.is_type(instance, "array"):
-        return
-
-    prefix = len(schema.get("prefixItems", []))
-    total = len(instance)
-    extra = total - prefix
-    if extra <= 0:
-        return
-
-    if items is False:
-        rest = instance[prefix:] if extra != 1 else instance[prefix]
-        item = "items" if prefix != 1 else "item"
-        yield ValidationError(
-            f"Expected at most {prefix} {item} but found {extra} "
-            f"extra: {rest!r}",
-        )
-    else:
-        for index in range(prefix, total):
-            yield from validator.descend(
-                instance=instance[index],
-                schema=items,
-                path=index,
-            )
-
-
-def const(validator, const, instance, schema):
-    if not equal(instance, const):
-        yield ValidationError(f"{const!r} was expected")
-
-
-def contains(validator, contains, instance, schema):
-    if not validator.is_type(instance, "array"):
-        return
-
-    matches = 0
-    min_contains = schema.get("minContains", 1)
-    max_contains = schema.get("maxContains", len(instance))
-
-    for each in instance:
-        if validator.evolve(schema=contains).is_valid(each):
-            matches += 1
-            if matches > max_contains:
-                yield ValidationError(
-                    "Too many items match the given schema "
-                    f"(expected at most {max_contains})",
-                    validator="maxContains",
-                    validator_value=max_contains,
-                )
-                return
-
-    if matches < min_contains:
-        if not matches:
-            yield ValidationError(
-                f"{instance!r} does not contain items "
-                "matching the given schema",
-            )
-        else:
-            yield ValidationError(
-                "Too few items match the given schema (expected at least "
-                f"{min_contains} but only {matches} matched)",
-                validator="minContains",
-                validator_value=min_contains,
-            )
-
-
-def exclusiveMinimum(validator, minimum, instance, schema):
-    if not validator.is_type(instance, "number"):
-        return
-
-    if instance <= minimum:
-        yield ValidationError(
-            f"{instance!r} is less than or equal to "
-            f"the minimum of {minimum!r}",
-        )
-
-
-def exclusiveMaximum(validator, maximum, instance, schema):
-    if not validator.is_type(instance, "number"):
-        return
-
-    if instance >= maximum:
-        yield ValidationError(
-            f"{instance!r} is greater than or equal "
-            f"to the maximum of {maximum!r}",
-        )
-
-
-def minimum(validator, minimum, instance, schema):
-    if not validator.is_type(instance, "number"):
-        return
-
-    if instance < minimum:
-        message = f"{instance!r} is less than the minimum of {minimum!r}"
-        yield ValidationError(message)
-
-
-def maximum(validator, maximum, instance, schema):
-    if not validator.is_type(instance, "number"):
-        return
-
-    if instance > maximum:
-        message = f"{instance!r} is greater than the maximum of {maximum!r}"
-        yield ValidationError(message)
-
-
-def multipleOf(validator, dB, instance, schema):
-    if not validator.is_type(instance, "number"):
-        return
-
-    if isinstance(dB, float):
-        quotient = instance / dB
-        try:
-            failed = int(quotient) != quotient
-        except OverflowError:
-            # When `instance` is large and `dB` is less than one,
-            # quotient can overflow to infinity; and then casting to int
-            # raises an error.
-            #
-            # In this case we fall back to Fraction logic, which is
-            # exact and cannot overflow.  The performance is also
-            # acceptable: we try the fast all-float option first, and
-            # we know that fraction(dB) can have at most a few hundred
-            # digits in each part.  The worst-case slowdown is therefore
-            # for already-slow enormous integers or Decimals.
-            failed = (Fraction(instance) / Fraction(dB)).denominator != 1
-    else:
-        failed = instance % dB
-
-    if failed:
-        yield ValidationError(f"{instance!r} is not a multiple of {dB}")
-
-
-def minItems(validator, mI, instance, schema):
-    if validator.is_type(instance, "array") and len(instance) < mI:
-        yield ValidationError(f"{instance!r} is too short")
-
-
-def maxItems(validator, mI, instance, schema):
-    if validator.is_type(instance, "array") and len(instance) > mI:
-        yield ValidationError(f"{instance!r} is too long")
-
-
-def uniqueItems(validator, uI, instance, schema):
-    if (
-        uI
-        and validator.is_type(instance, "array")
-        and not uniq(instance)
-    ):
-        yield ValidationError(f"{instance!r} has non-unique elements")
-
-
-def pattern(validator, patrn, instance, schema):
-    if (
-        validator.is_type(instance, "string")
-        and not re.search(patrn, instance)
-    ):
-        yield ValidationError(f"{instance!r} does not match {patrn!r}")
-
-
-def format(validator, format, instance, schema):
-    if validator.format_checker is not None:
-        try:
-            validator.format_checker.check(instance, format)
-        except FormatError as error:
-            yield ValidationError(error.message, cause=error.cause)
-
-
-def minLength(validator, mL, instance, schema):
-    if validator.is_type(instance, "string") and len(instance) < mL:
-        yield ValidationError(f"{instance!r} is too short")
-
-
-def maxLength(validator, mL, instance, schema):
-    if validator.is_type(instance, "string") and len(instance) > mL:
-        yield ValidationError(f"{instance!r} is too long")
-
-
-def dependentRequired(validator, dependentRequired, instance, schema):
-    if not validator.is_type(instance, "object"):
-        return
-
-    for property, dependency in dependentRequired.items():
-        if property not in instance:
-            continue
-
-        for each in dependency:
-            if each not in instance:
-                message = f"{each!r} is a dependency of {property!r}"
-                yield ValidationError(message)
-
-
-def dependentSchemas(validator, dependentSchemas, instance, schema):
-    if not validator.is_type(instance, "object"):
-        return
-
-    for property, dependency in dependentSchemas.items():
-        if property not in instance:
-            continue
-        yield from validator.descend(
-            instance, dependency, schema_path=property,
-        )
-
-
-def enum(validator, enums, instance, schema):
-    if instance == 0 or instance == 1:
-        unbooled = unbool(instance)
-        if all(unbooled != unbool(each) for each in enums):
-            yield ValidationError(f"{instance!r} is not one of {enums!r}")
-    elif instance not in enums:
-        yield ValidationError(f"{instance!r} is not one of {enums!r}")
-
-
-def ref(validator, ref, instance, schema):
-    yield from validator._validate_reference(ref=ref, instance=instance)
-
-
-def dynamicRef(validator, dynamicRef, instance, schema):
-    yield from validator._validate_reference(ref=dynamicRef, instance=instance)
-
-
-def type(validator, types, instance, schema):
-    types = ensure_list(types)
-
-    if not any(validator.is_type(instance, type) for type in types):
-        reprs = ", ".join(repr(type) for type in types)
-        yield ValidationError(f"{instance!r} is not of type {reprs}")
-
-
-def properties(validator, properties, instance, schema):
-    if not validator.is_type(instance, "object"):
-        return
-
-    for property, subschema in properties.items():
-        if property in instance:
-            yield from validator.descend(
-                instance[property],
-                subschema,
-                path=property,
-                schema_path=property,
-            )
-
-
-def required(validator, required, instance, schema):
-    if not validator.is_type(instance, "object"):
-        return
-    for property in required:
-        if property not in instance:
-            yield ValidationError(f"{property!r} is a required property")
-
-
-def minProperties(validator, mP, instance, schema):
-    if validator.is_type(instance, "object") and len(instance) < mP:
-        yield ValidationError(f"{instance!r} does not have enough properties")
-
-
-def maxProperties(validator, mP, instance, schema):
-    if not validator.is_type(instance, "object"):
-        return
-    if validator.is_type(instance, "object") and len(instance) > mP:
-        yield ValidationError(f"{instance!r} has too many properties")
-
-
-def allOf(validator, allOf, instance, schema):
-    for index, subschema in enumerate(allOf):
-        yield from validator.descend(instance, subschema, schema_path=index)
-
-
-def anyOf(validator, anyOf, instance, schema):
-    all_errors = []
-    for index, subschema in enumerate(anyOf):
-        errs = list(validator.descend(instance, subschema, schema_path=index))
-        if not errs:
-            break
-        all_errors.extend(errs)
-    else:
-        yield ValidationError(
-            f"{instance!r} is not valid under any of the given schemas",
-            context=all_errors,
-        )
-
-
-def oneOf(validator, oneOf, instance, schema):
-    subschemas = enumerate(oneOf)
-    all_errors = []
-    for index, subschema in subschemas:
-        errs = list(validator.descend(instance, subschema, schema_path=index))
-        if not errs:
-            first_valid = subschema
-            break
-        all_errors.extend(errs)
-    else:
-        yield ValidationError(
-            f"{instance!r} is not valid under any of the given schemas",
-            context=all_errors,
-        )
-
-    more_valid = [
-        each for _, each in subschemas
-        if validator.evolve(schema=each).is_valid(instance)
-    ]
-    if more_valid:
-        more_valid.append(first_valid)
-        reprs = ", ".join(repr(schema) for schema in more_valid)
-        yield ValidationError(f"{instance!r} is valid under each of {reprs}")
-
-
-def not_(validator, not_schema, instance, schema):
-    if validator.evolve(schema=not_schema).is_valid(instance):
-        message = f"{instance!r} should not be valid under {not_schema!r}"
-        yield ValidationError(message)
-
-
-def if_(validator, if_schema, instance, schema):
-    if validator.evolve(schema=if_schema).is_valid(instance):
-        if "then" in schema:
-            then = schema["then"]
-            yield from validator.descend(instance, then, schema_path="then")
-    elif "else" in schema:
-        else_ = schema["else"]
-        yield from validator.descend(instance, else_, schema_path="else")
-
-
-def unevaluatedItems(validator, unevaluatedItems, instance, schema):
-    if not validator.is_type(instance, "array"):
-        return
-    evaluated_item_indexes = find_evaluated_item_indexes_by_schema(
-        validator, instance, schema,
-    )
-    unevaluated_items = [
-        item for index, item in enumerate(instance)
-        if index not in evaluated_item_indexes
-    ]
-    if unevaluated_items:
-        error = "Unevaluated items are not allowed (%s %s unexpected)"
-        yield ValidationError(error % extras_msg(unevaluated_items))
-
-
-def unevaluatedProperties(validator, unevaluatedProperties, instance, schema):
-    if not validator.is_type(instance, "object"):
-        return
-    evaluated_keys = find_evaluated_property_keys_by_schema(
-        validator, instance, schema,
-    )
-    unevaluated_keys = []
-    for property in instance:
-        if property not in evaluated_keys:
-            for _ in validator.descend(
-                instance[property],
-                unevaluatedProperties,
-                path=property,
-                schema_path=property,
-            ):
-                # FIXME: Include context for each unevaluated property
-                #        indicating why it's invalid under the subschema.
-                unevaluated_keys.append(property)
-
-    if unevaluated_keys:
-        if unevaluatedProperties is False:
-            error = "Unevaluated properties are not allowed (%s %s unexpected)"
-            extras = sorted(unevaluated_keys, key=str)
-            yield ValidationError(error % extras_msg(extras))
-        else:
-            error = (
-                "Unevaluated properties are not valid under "
-                "the given schema (%s %s unevaluated and invalid)"
-            )
-            yield ValidationError(error % extras_msg(unevaluated_keys))
-
-
-def prefixItems(validator, prefixItems, instance, schema):
-    if not validator.is_type(instance, "array"):
-        return
-
-    for (index, item), subschema in zip(enumerate(instance), prefixItems):
-        yield from validator.descend(
-            instance=item,
-            schema=subschema,
-            schema_path=index,
-            path=index,
-        )
diff --git a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/pandas/tests/indexes/categorical/test_map.py b/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/pandas/tests/indexes/categorical/test_map.py
deleted file mode 100644
index baf836594dfb5e03332b57522f39a679ee5b1e40..0000000000000000000000000000000000000000
--- a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/pandas/tests/indexes/categorical/test_map.py
+++ /dev/null
@@ -1,144 +0,0 @@
-import numpy as np
-import pytest
-
-import pandas as pd
-from pandas import (
-    CategoricalIndex,
-    Index,
-    Series,
-)
-import pandas._testing as tm
-
-
-@pytest.mark.parametrize(
-    "data, categories",
-    [
-        (list("abcbca"), list("cab")),
-        (pd.interval_range(0, 3).repeat(3), pd.interval_range(0, 3)),
-    ],
-    ids=["string", "interval"],
-)
-def test_map_str(data, categories, ordered):
-    # GH 31202 - override base class since we want to maintain categorical/ordered
-    index = CategoricalIndex(data, categories=categories, ordered=ordered)
-    result = index.map(str)
-    expected = CategoricalIndex(
-        map(str, data), categories=map(str, categories), ordered=ordered
-    )
-    tm.assert_index_equal(result, expected)
-
-
-def test_map():
-    ci = CategoricalIndex(list("ABABC"), categories=list("CBA"), ordered=True)
-    result = ci.map(lambda x: x.lower())
-    exp = CategoricalIndex(list("ababc"), categories=list("cba"), ordered=True)
-    tm.assert_index_equal(result, exp)
-
-    ci = CategoricalIndex(
-        list("ABABC"), categories=list("BAC"), ordered=False, name="XXX"
-    )
-    result = ci.map(lambda x: x.lower())
-    exp = CategoricalIndex(
-        list("ababc"), categories=list("bac"), ordered=False, name="XXX"
-    )
-    tm.assert_index_equal(result, exp)
-
-    # GH 12766: Return an index not an array
-    tm.assert_index_equal(
-        ci.map(lambda x: 1), Index(np.array([1] * 5, dtype=np.int64), name="XXX")
-    )
-
-    # change categories dtype
-    ci = CategoricalIndex(list("ABABC"), categories=list("BAC"), ordered=False)
-
-    def f(x):
-        return {"A": 10, "B": 20, "C": 30}.get(x)
-
-    result = ci.map(f)
-    exp = CategoricalIndex([10, 20, 10, 20, 30], categories=[20, 10, 30], ordered=False)
-    tm.assert_index_equal(result, exp)
-
-    result = ci.map(Series([10, 20, 30], index=["A", "B", "C"]))
-    tm.assert_index_equal(result, exp)
-
-    result = ci.map({"A": 10, "B": 20, "C": 30})
-    tm.assert_index_equal(result, exp)
-
-
-def test_map_with_categorical_series():
-    # GH 12756
-    a = Index([1, 2, 3, 4])
-    b = Series(["even", "odd", "even", "odd"], dtype="category")
-    c = Series(["even", "odd", "even", "odd"])
-
-    exp = CategoricalIndex(["odd", "even", "odd", np.nan])
-    tm.assert_index_equal(a.map(b), exp)
-    exp = Index(["odd", "even", "odd", np.nan])
-    tm.assert_index_equal(a.map(c), exp)
-
-
-@pytest.mark.parametrize(
-    ("data", "f", "expected"),
-    (
-        ([1, 1, np.nan], pd.isna, CategoricalIndex([False, False, np.nan])),
-        ([1, 2, np.nan], pd.isna, Index([False, False, np.nan])),
-        ([1, 1, np.nan], {1: False}, CategoricalIndex([False, False, np.nan])),
-        ([1, 2, np.nan], {1: False, 2: False}, Index([False, False, np.nan])),
-        (
-            [1, 1, np.nan],
-            Series([False, False]),
-            CategoricalIndex([False, False, np.nan]),
-        ),
-        (
-            [1, 2, np.nan],
-            Series([False, False, False]),
-            Index([False, False, np.nan]),
-        ),
-    ),
-)
-def test_map_with_nan_ignore(data, f, expected):  # GH 24241
-    values = CategoricalIndex(data)
-    result = values.map(f, na_action="ignore")
-    tm.assert_index_equal(result, expected)
-
-
-@pytest.mark.parametrize(
-    ("data", "f", "expected"),
-    (
-        ([1, 1, np.nan], pd.isna, Index([False, False, True])),
-        ([1, 2, np.nan], pd.isna, Index([False, False, True])),
-        ([1, 1, np.nan], {1: False}, CategoricalIndex([False, False, np.nan])),
-        ([1, 2, np.nan], {1: False, 2: False}, Index([False, False, np.nan])),
-        (
-            [1, 1, np.nan],
-            Series([False, False]),
-            CategoricalIndex([False, False, np.nan]),
-        ),
-        (
-            [1, 2, np.nan],
-            Series([False, False, False]),
-            Index([False, False, np.nan]),
-        ),
-    ),
-)
-def test_map_with_nan_none(data, f, expected):  # GH 24241
-    values = CategoricalIndex(data)
-    result = values.map(f, na_action=None)
-    tm.assert_index_equal(result, expected)
-
-
-def test_map_with_dict_or_series():
-    orig_values = ["a", "B", 1, "a"]
-    new_values = ["one", 2, 3.0, "one"]
-    cur_index = CategoricalIndex(orig_values, name="XXX")
-    expected = CategoricalIndex(new_values, name="XXX", categories=[3.0, 2, "one"])
-
-    mapper = Series(new_values[:-1], index=orig_values[:-1])
-    result = cur_index.map(mapper)
-    # Order of categories in result can be different
-    tm.assert_index_equal(result, expected)
-
-    mapper = dict(zip(orig_values[:-1], new_values[:-1]))
-    result = cur_index.map(mapper)
-    # Order of categories in result can be different
-    tm.assert_index_equal(result, expected)
diff --git a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/pandas/tests/plotting/test_boxplot_method.py b/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/pandas/tests/plotting/test_boxplot_method.py
deleted file mode 100644
index 555b9fd0c82c29dba47ef50be38649e762b90d18..0000000000000000000000000000000000000000
--- a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/pandas/tests/plotting/test_boxplot_method.py
+++ /dev/null
@@ -1,745 +0,0 @@
-""" Test cases for .boxplot method """
-
-import itertools
-import string
-
-import numpy as np
-import pytest
-
-from pandas import (
-    DataFrame,
-    MultiIndex,
-    Series,
-    date_range,
-    plotting,
-    timedelta_range,
-)
-import pandas._testing as tm
-from pandas.tests.plotting.common import (
-    _check_axes_shape,
-    _check_box_return_type,
-    _check_plot_works,
-    _check_ticks_props,
-    _check_visible,
-)
-
-from pandas.io.formats.printing import pprint_thing
-
-mpl = pytest.importorskip("matplotlib")
-plt = pytest.importorskip("matplotlib.pyplot")
-
-
-def _check_ax_limits(col, ax):
-    y_min, y_max = ax.get_ylim()
-    assert y_min <= col.min()
-    assert y_max >= col.max()
-
-
-class TestDataFramePlots:
-    def test_stacked_boxplot_set_axis(self):
-        # GH2980
-        import matplotlib.pyplot as plt
-
-        n = 80
-        df = DataFrame(
-            {
-                "Clinical": np.random.default_rng(2).choice([0, 1, 2, 3], n),
-                "Confirmed": np.random.default_rng(2).choice([0, 1, 2, 3], n),
-                "Discarded": np.random.default_rng(2).choice([0, 1, 2, 3], n),
-            },
-            index=np.arange(0, n),
-        )
-        ax = df.plot(kind="bar", stacked=True)
-        assert [int(x.get_text()) for x in ax.get_xticklabels()] == df.index.to_list()
-        ax.set_xticks(np.arange(0, 80, 10))
-        plt.draw()  # Update changes
-        assert [int(x.get_text()) for x in ax.get_xticklabels()] == list(
-            np.arange(0, 80, 10)
-        )
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize(
-        "kwargs, warn",
-        [
-            [{"return_type": "dict"}, None],
-            [{"column": ["one", "two"]}, None],
-            [{"column": ["one", "two"], "by": "indic"}, UserWarning],
-            [{"column": ["one"], "by": ["indic", "indic2"]}, None],
-            [{"by": "indic"}, UserWarning],
-            [{"by": ["indic", "indic2"]}, UserWarning],
-            [{"notch": 1}, None],
-            [{"by": "indic", "notch": 1}, UserWarning],
-        ],
-    )
-    def test_boxplot_legacy1(self, kwargs, warn):
-        df = DataFrame(
-            np.random.default_rng(2).standard_normal((6, 4)),
-            index=list(string.ascii_letters[:6]),
-            columns=["one", "two", "three", "four"],
-        )
-        df["indic"] = ["foo", "bar"] * 3
-        df["indic2"] = ["foo", "bar", "foo"] * 2
-
-        # _check_plot_works can add an ax so catch warning. see GH #13188
-        with tm.assert_produces_warning(warn, check_stacklevel=False):
-            _check_plot_works(df.boxplot, **kwargs)
-
-    def test_boxplot_legacy1_series(self):
-        ser = Series(np.random.default_rng(2).standard_normal(6))
-        _check_plot_works(plotting._core.boxplot, data=ser, return_type="dict")
-
-    def test_boxplot_legacy2(self):
-        df = DataFrame(
-            np.random.default_rng(2).random((10, 2)), columns=["Col1", "Col2"]
-        )
-        df["X"] = Series(["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"])
-        df["Y"] = Series(["A"] * 10)
-        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
-            _check_plot_works(df.boxplot, by="X")
-
-    def test_boxplot_legacy2_with_ax(self):
-        df = DataFrame(
-            np.random.default_rng(2).random((10, 2)), columns=["Col1", "Col2"]
-        )
-        df["X"] = Series(["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"])
-        df["Y"] = Series(["A"] * 10)
-        # When ax is supplied and required number of axes is 1,
-        # passed ax should be used:
-        _, ax = mpl.pyplot.subplots()
-        axes = df.boxplot("Col1", by="X", ax=ax)
-        ax_axes = ax.axes
-        assert ax_axes is axes
-
-    def test_boxplot_legacy2_with_ax_return_type(self):
-        df = DataFrame(
-            np.random.default_rng(2).random((10, 2)), columns=["Col1", "Col2"]
-        )
-        df["X"] = Series(["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"])
-        df["Y"] = Series(["A"] * 10)
-        fig, ax = mpl.pyplot.subplots()
-        axes = df.groupby("Y").boxplot(ax=ax, return_type="axes")
-        ax_axes = ax.axes
-        assert ax_axes is axes["A"]
-
-    def test_boxplot_legacy2_with_multi_col(self):
-        df = DataFrame(
-            np.random.default_rng(2).random((10, 2)), columns=["Col1", "Col2"]
-        )
-        df["X"] = Series(["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"])
-        df["Y"] = Series(["A"] * 10)
-        # Multiple columns with an ax argument should use same figure
-        fig, ax = mpl.pyplot.subplots()
-        with tm.assert_produces_warning(UserWarning):
-            axes = df.boxplot(
-                column=["Col1", "Col2"], by="X", ax=ax, return_type="axes"
-            )
-        assert axes["Col1"].get_figure() is fig
-
-    def test_boxplot_legacy2_by_none(self):
-        df = DataFrame(
-            np.random.default_rng(2).random((10, 2)), columns=["Col1", "Col2"]
-        )
-        df["X"] = Series(["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"])
-        df["Y"] = Series(["A"] * 10)
-        # When by is None, check that all relevant lines are present in the
-        # dict
-        _, ax = mpl.pyplot.subplots()
-        d = df.boxplot(ax=ax, return_type="dict")
-        lines = list(itertools.chain.from_iterable(d.values()))
-        assert len(ax.get_lines()) == len(lines)
-
-    def test_boxplot_return_type_none(self, hist_df):
-        # GH 12216; return_type=None & by=None -> axes
-        result = hist_df.boxplot()
-        assert isinstance(result, mpl.pyplot.Axes)
-
-    def test_boxplot_return_type_legacy(self):
-        # API change in https://github.com/pandas-dev/pandas/pull/7096
-
-        df = DataFrame(
-            np.random.default_rng(2).standard_normal((6, 4)),
-            index=list(string.ascii_letters[:6]),
-            columns=["one", "two", "three", "four"],
-        )
-        msg = "return_type must be {'axes', 'dict', 'both'}"
-        with pytest.raises(ValueError, match=msg):
-            df.boxplot(return_type="NOT_A_TYPE")
-
-        result = df.boxplot()
-        _check_box_return_type(result, "axes")
-
-    @pytest.mark.parametrize("return_type", ["dict", "axes", "both"])
-    def test_boxplot_return_type_legacy_return_type(self, return_type):
-        # API change in https://github.com/pandas-dev/pandas/pull/7096
-
-        df = DataFrame(
-            np.random.default_rng(2).standard_normal((6, 4)),
-            index=list(string.ascii_letters[:6]),
-            columns=["one", "two", "three", "four"],
-        )
-        with tm.assert_produces_warning(False):
-            result = df.boxplot(return_type=return_type)
-        _check_box_return_type(result, return_type)
-
-    def test_boxplot_axis_limits(self, hist_df):
-        df = hist_df.copy()
-        df["age"] = np.random.default_rng(2).integers(1, 20, df.shape[0])
-        # One full row
-        height_ax, weight_ax = df.boxplot(["height", "weight"], by="category")
-        _check_ax_limits(df["height"], height_ax)
-        _check_ax_limits(df["weight"], weight_ax)
-        assert weight_ax._sharey == height_ax
-
-    def test_boxplot_axis_limits_two_rows(self, hist_df):
-        df = hist_df.copy()
-        df["age"] = np.random.default_rng(2).integers(1, 20, df.shape[0])
-        # Two rows, one partial
-        p = df.boxplot(["height", "weight", "age"], by="category")
-        height_ax, weight_ax, age_ax = p[0, 0], p[0, 1], p[1, 0]
-        dummy_ax = p[1, 1]
-
-        _check_ax_limits(df["height"], height_ax)
-        _check_ax_limits(df["weight"], weight_ax)
-        _check_ax_limits(df["age"], age_ax)
-        assert weight_ax._sharey == height_ax
-        assert age_ax._sharey == height_ax
-        assert dummy_ax._sharey is None
-
-    def test_boxplot_empty_column(self):
-        df = DataFrame(np.random.default_rng(2).standard_normal((20, 4)))
-        df.loc[:, 0] = np.nan
-        _check_plot_works(df.boxplot, return_type="axes")
-
-    def test_figsize(self):
-        df = DataFrame(
-            np.random.default_rng(2).random((10, 5)), columns=["A", "B", "C", "D", "E"]
-        )
-        result = df.boxplot(return_type="axes", figsize=(12, 8))
-        assert result.figure.bbox_inches.width == 12
-        assert result.figure.bbox_inches.height == 8
-
-    def test_fontsize(self):
-        df = DataFrame({"a": [1, 2, 3, 4, 5, 6]})
-        _check_ticks_props(df.boxplot("a", fontsize=16), xlabelsize=16, ylabelsize=16)
-
-    def test_boxplot_numeric_data(self):
-        # GH 22799
-        df = DataFrame(
-            {
-                "a": date_range("2012-01-01", periods=100),
-                "b": np.random.default_rng(2).standard_normal(100),
-                "c": np.random.default_rng(2).standard_normal(100) + 2,
-                "d": date_range("2012-01-01", periods=100).astype(str),
-                "e": date_range("2012-01-01", periods=100, tz="UTC"),
-                "f": timedelta_range("1 days", periods=100),
-            }
-        )
-        ax = df.plot(kind="box")
-        assert [x.get_text() for x in ax.get_xticklabels()] == ["b", "c"]
-
-    @pytest.mark.parametrize(
-        "colors_kwd, expected",
-        [
-            (
-                {"boxes": "r", "whiskers": "b", "medians": "g", "caps": "c"},
-                {"boxes": "r", "whiskers": "b", "medians": "g", "caps": "c"},
-            ),
-            ({"boxes": "r"}, {"boxes": "r"}),
-            ("r", {"boxes": "r", "whiskers": "r", "medians": "r", "caps": "r"}),
-        ],
-    )
-    def test_color_kwd(self, colors_kwd, expected):
-        # GH: 26214
-        df = DataFrame(np.random.default_rng(2).random((10, 2)))
-        result = df.boxplot(color=colors_kwd, return_type="dict")
-        for k, v in expected.items():
-            assert result[k][0].get_color() == v
-
-    @pytest.mark.parametrize(
-        "scheme,expected",
-        [
-            (
-                "dark_background",
-                {
-                    "boxes": "#8dd3c7",
-                    "whiskers": "#8dd3c7",
-                    "medians": "#bfbbd9",
-                    "caps": "#8dd3c7",
-                },
-            ),
-            (
-                "default",
-                {
-                    "boxes": "#1f77b4",
-                    "whiskers": "#1f77b4",
-                    "medians": "#2ca02c",
-                    "caps": "#1f77b4",
-                },
-            ),
-        ],
-    )
-    def test_colors_in_theme(self, scheme, expected):
-        # GH: 40769
-        df = DataFrame(np.random.default_rng(2).random((10, 2)))
-        import matplotlib.pyplot as plt
-
-        plt.style.use(scheme)
-        result = df.plot.box(return_type="dict")
-        for k, v in expected.items():
-            assert result[k][0].get_color() == v
-
-    @pytest.mark.parametrize(
-        "dict_colors, msg",
-        [({"boxes": "r", "invalid_key": "r"}, "invalid key 'invalid_key'")],
-    )
-    def test_color_kwd_errors(self, dict_colors, msg):
-        # GH: 26214
-        df = DataFrame(np.random.default_rng(2).random((10, 2)))
-        with pytest.raises(ValueError, match=msg):
-            df.boxplot(color=dict_colors, return_type="dict")
-
-    @pytest.mark.parametrize(
-        "props, expected",
-        [
-            ("boxprops", "boxes"),
-            ("whiskerprops", "whiskers"),
-            ("capprops", "caps"),
-            ("medianprops", "medians"),
-        ],
-    )
-    def test_specified_props_kwd(self, props, expected):
-        # GH 30346
-        df = DataFrame({k: np.random.default_rng(2).random(10) for k in "ABC"})
-        kwd = {props: {"color": "C1"}}
-        result = df.boxplot(return_type="dict", **kwd)
-
-        assert result[expected][0].get_color() == "C1"
-
-    @pytest.mark.parametrize("vert", [True, False])
-    def test_plot_xlabel_ylabel(self, vert):
-        df = DataFrame(
-            {
-                "a": np.random.default_rng(2).standard_normal(10),
-                "b": np.random.default_rng(2).standard_normal(10),
-                "group": np.random.default_rng(2).choice(["group1", "group2"], 10),
-            }
-        )
-        xlabel, ylabel = "x", "y"
-        ax = df.plot(kind="box", vert=vert, xlabel=xlabel, ylabel=ylabel)
-        assert ax.get_xlabel() == xlabel
-        assert ax.get_ylabel() == ylabel
-
-    @pytest.mark.parametrize("vert", [True, False])
-    def test_boxplot_xlabel_ylabel(self, vert):
-        df = DataFrame(
-            {
-                "a": np.random.default_rng(2).standard_normal(10),
-                "b": np.random.default_rng(2).standard_normal(10),
-                "group": np.random.default_rng(2).choice(["group1", "group2"], 10),
-            }
-        )
-        xlabel, ylabel = "x", "y"
-        ax = df.boxplot(vert=vert, xlabel=xlabel, ylabel=ylabel)
-        assert ax.get_xlabel() == xlabel
-        assert ax.get_ylabel() == ylabel
-
-    @pytest.mark.parametrize("vert", [True, False])
-    def test_boxplot_group_xlabel_ylabel(self, vert):
-        df = DataFrame(
-            {
-                "a": np.random.default_rng(2).standard_normal(10),
-                "b": np.random.default_rng(2).standard_normal(10),
-                "group": np.random.default_rng(2).choice(["group1", "group2"], 10),
-            }
-        )
-        xlabel, ylabel = "x", "y"
-        ax = df.boxplot(by="group", vert=vert, xlabel=xlabel, ylabel=ylabel)
-        for subplot in ax:
-            assert subplot.get_xlabel() == xlabel
-            assert subplot.get_ylabel() == ylabel
-        mpl.pyplot.close()
-
-    @pytest.mark.parametrize("vert", [True, False])
-    def test_boxplot_group_no_xlabel_ylabel(self, vert):
-        df = DataFrame(
-            {
-                "a": np.random.default_rng(2).standard_normal(10),
-                "b": np.random.default_rng(2).standard_normal(10),
-                "group": np.random.default_rng(2).choice(["group1", "group2"], 10),
-            }
-        )
-        ax = df.boxplot(by="group", vert=vert)
-        for subplot in ax:
-            target_label = subplot.get_xlabel() if vert else subplot.get_ylabel()
-            assert target_label == pprint_thing(["group"])
-        mpl.pyplot.close()
-
-
-class TestDataFrameGroupByPlots:
-    def test_boxplot_legacy1(self, hist_df):
-        grouped = hist_df.groupby(by="gender")
-        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
-            axes = _check_plot_works(grouped.boxplot, return_type="axes")
-        _check_axes_shape(list(axes.values), axes_num=2, layout=(1, 2))
-
-    def test_boxplot_legacy1_return_type(self, hist_df):
-        grouped = hist_df.groupby(by="gender")
-        axes = _check_plot_works(grouped.boxplot, subplots=False, return_type="axes")
-        _check_axes_shape(axes, axes_num=1, layout=(1, 1))
-
-    @pytest.mark.slow
-    def test_boxplot_legacy2(self):
-        tuples = zip(string.ascii_letters[:10], range(10))
-        df = DataFrame(
-            np.random.default_rng(2).random((10, 3)),
-            index=MultiIndex.from_tuples(tuples),
-        )
-        grouped = df.groupby(level=1)
-        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
-            axes = _check_plot_works(grouped.boxplot, return_type="axes")
-        _check_axes_shape(list(axes.values), axes_num=10, layout=(4, 3))
-
-    @pytest.mark.slow
-    def test_boxplot_legacy2_return_type(self):
-        tuples = zip(string.ascii_letters[:10], range(10))
-        df = DataFrame(
-            np.random.default_rng(2).random((10, 3)),
-            index=MultiIndex.from_tuples(tuples),
-        )
-        grouped = df.groupby(level=1)
-        axes = _check_plot_works(grouped.boxplot, subplots=False, return_type="axes")
-        _check_axes_shape(axes, axes_num=1, layout=(1, 1))
-
-    @pytest.mark.parametrize(
-        "subplots, warn, axes_num, layout",
-        [[True, UserWarning, 3, (2, 2)], [False, None, 1, (1, 1)]],
-    )
-    def test_boxplot_legacy3(self, subplots, warn, axes_num, layout):
-        tuples = zip(string.ascii_letters[:10], range(10))
-        df = DataFrame(
-            np.random.default_rng(2).random((10, 3)),
-            index=MultiIndex.from_tuples(tuples),
-        )
-        msg = "DataFrame.groupby with axis=1 is deprecated"
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            grouped = df.unstack(level=1).groupby(level=0, axis=1)
-        with tm.assert_produces_warning(warn, check_stacklevel=False):
-            axes = _check_plot_works(
-                grouped.boxplot, subplots=subplots, return_type="axes"
-            )
-        _check_axes_shape(axes, axes_num=axes_num, layout=layout)
-
-    def test_grouped_plot_fignums(self):
-        n = 10
-        weight = Series(np.random.default_rng(2).normal(166, 20, size=n))
-        height = Series(np.random.default_rng(2).normal(60, 10, size=n))
-        gender = np.random.default_rng(2).choice(["male", "female"], size=n)
-        df = DataFrame({"height": height, "weight": weight, "gender": gender})
-        gb = df.groupby("gender")
-
-        res = gb.plot()
-        assert len(mpl.pyplot.get_fignums()) == 2
-        assert len(res) == 2
-        plt.close("all")
-
-        res = gb.boxplot(return_type="axes")
-        assert len(mpl.pyplot.get_fignums()) == 1
-        assert len(res) == 2
-
-    def test_grouped_plot_fignums_excluded_col(self):
-        n = 10
-        weight = Series(np.random.default_rng(2).normal(166, 20, size=n))
-        height = Series(np.random.default_rng(2).normal(60, 10, size=n))
-        gender = np.random.default_rng(2).choice(["male", "female"], size=n)
-        df = DataFrame({"height": height, "weight": weight, "gender": gender})
-        # now works with GH 5610 as gender is excluded
-        df.groupby("gender").hist()
-
-    @pytest.mark.slow
-    def test_grouped_box_return_type(self, hist_df):
-        df = hist_df
-
-        # old style: return_type=None
-        result = df.boxplot(by="gender")
-        assert isinstance(result, np.ndarray)
-        _check_box_return_type(
-            result, None, expected_keys=["height", "weight", "category"]
-        )
-
-    @pytest.mark.slow
-    def test_grouped_box_return_type_groupby(self, hist_df):
-        df = hist_df
-        # now for groupby
-        result = df.groupby("gender").boxplot(return_type="dict")
-        _check_box_return_type(result, "dict", expected_keys=["Male", "Female"])
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize("return_type", ["dict", "axes", "both"])
-    def test_grouped_box_return_type_arg(self, hist_df, return_type):
-        df = hist_df
-
-        returned = df.groupby("classroom").boxplot(return_type=return_type)
-        _check_box_return_type(returned, return_type, expected_keys=["A", "B", "C"])
-
-        returned = df.boxplot(by="classroom", return_type=return_type)
-        _check_box_return_type(
-            returned, return_type, expected_keys=["height", "weight", "category"]
-        )
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize("return_type", ["dict", "axes", "both"])
-    def test_grouped_box_return_type_arg_duplcate_cats(self, return_type):
-        columns2 = "X B C D A".split()
-        df2 = DataFrame(
-            np.random.default_rng(2).standard_normal((6, 5)), columns=columns2
-        )
-        categories2 = "A B".split()
-        df2["category"] = categories2 * 3
-
-        returned = df2.groupby("category").boxplot(return_type=return_type)
-        _check_box_return_type(returned, return_type, expected_keys=categories2)
-
-        returned = df2.boxplot(by="category", return_type=return_type)
-        _check_box_return_type(returned, return_type, expected_keys=columns2)
-
-    @pytest.mark.slow
-    def test_grouped_box_layout_too_small(self, hist_df):
-        df = hist_df
-
-        msg = "Layout of 1x1 must be larger than required size 2"
-        with pytest.raises(ValueError, match=msg):
-            df.boxplot(column=["weight", "height"], by=df.gender, layout=(1, 1))
-
-    @pytest.mark.slow
-    def test_grouped_box_layout_needs_by(self, hist_df):
-        df = hist_df
-        msg = "The 'layout' keyword is not supported when 'by' is None"
-        with pytest.raises(ValueError, match=msg):
-            df.boxplot(
-                column=["height", "weight", "category"],
-                layout=(2, 1),
-                return_type="dict",
-            )
-
-    @pytest.mark.slow
-    def test_grouped_box_layout_positive_layout(self, hist_df):
-        df = hist_df
-        msg = "At least one dimension of layout must be positive"
-        with pytest.raises(ValueError, match=msg):
-            df.boxplot(column=["weight", "height"], by=df.gender, layout=(-1, -1))
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize(
-        "gb_key, axes_num, rows",
-        [["gender", 2, 1], ["category", 4, 2], ["classroom", 3, 2]],
-    )
-    def test_grouped_box_layout_positive_layout_axes(
-        self, hist_df, gb_key, axes_num, rows
-    ):
-        df = hist_df
-        # _check_plot_works adds an ax so catch warning. see GH #13188 GH 6769
-        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
-            _check_plot_works(
-                df.groupby(gb_key).boxplot, column="height", return_type="dict"
-            )
-        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=axes_num, layout=(rows, 2))
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize(
-        "col, visible", [["height", False], ["weight", True], ["category", True]]
-    )
-    def test_grouped_box_layout_visible(self, hist_df, col, visible):
-        df = hist_df
-        # GH 5897
-        axes = df.boxplot(
-            column=["height", "weight", "category"], by="gender", return_type="axes"
-        )
-        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=3, layout=(2, 2))
-        ax = axes[col]
-        _check_visible(ax.get_xticklabels(), visible=visible)
-        _check_visible([ax.xaxis.get_label()], visible=visible)
-
-    @pytest.mark.slow
-    def test_grouped_box_layout_shape(self, hist_df):
-        df = hist_df
-        df.groupby("classroom").boxplot(
-            column=["height", "weight", "category"], return_type="dict"
-        )
-        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=3, layout=(2, 2))
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize("cols", [2, -1])
-    def test_grouped_box_layout_works(self, hist_df, cols):
-        df = hist_df
-        with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
-            _check_plot_works(
-                df.groupby("category").boxplot,
-                column="height",
-                layout=(3, cols),
-                return_type="dict",
-            )
-        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=4, layout=(3, 2))
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize("rows, res", [[4, 4], [-1, 3]])
-    def test_grouped_box_layout_axes_shape_rows(self, hist_df, rows, res):
-        df = hist_df
-        df.boxplot(
-            column=["height", "weight", "category"], by="gender", layout=(rows, 1)
-        )
-        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=3, layout=(res, 1))
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize("cols, res", [[4, 4], [-1, 3]])
-    def test_grouped_box_layout_axes_shape_cols_groupby(self, hist_df, cols, res):
-        df = hist_df
-        df.groupby("classroom").boxplot(
-            column=["height", "weight", "category"],
-            layout=(1, cols),
-            return_type="dict",
-        )
-        _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=3, layout=(1, res))
-
-    @pytest.mark.slow
-    def test_grouped_box_multiple_axes(self, hist_df):
-        # GH 6970, GH 7069
-        df = hist_df
-
-        # check warning to ignore sharex / sharey
-        # this check should be done in the first function which
-        # passes multiple axes to plot, hist or boxplot
-        # location should be changed if other test is added
-        # which has earlier alphabetical order
-        with tm.assert_produces_warning(UserWarning):
-            _, axes = mpl.pyplot.subplots(2, 2)
-            df.groupby("category").boxplot(column="height", return_type="axes", ax=axes)
-            _check_axes_shape(mpl.pyplot.gcf().axes, axes_num=4, layout=(2, 2))
-
-    @pytest.mark.slow
-    def test_grouped_box_multiple_axes_on_fig(self, hist_df):
-        # GH 6970, GH 7069
-        df = hist_df
-        fig, axes = mpl.pyplot.subplots(2, 3)
-        with tm.assert_produces_warning(UserWarning):
-            returned = df.boxplot(
-                column=["height", "weight", "category"],
-                by="gender",
-                return_type="axes",
-                ax=axes[0],
-            )
-        returned = np.array(list(returned.values))
-        _check_axes_shape(returned, axes_num=3, layout=(1, 3))
-        tm.assert_numpy_array_equal(returned, axes[0])
-        assert returned[0].figure is fig
-
-        # draw on second row
-        with tm.assert_produces_warning(UserWarning):
-            returned = df.groupby("classroom").boxplot(
-                column=["height", "weight", "category"], return_type="axes", ax=axes[1]
-            )
-        returned = np.array(list(returned.values))
-        _check_axes_shape(returned, axes_num=3, layout=(1, 3))
-        tm.assert_numpy_array_equal(returned, axes[1])
-        assert returned[0].figure is fig
-
-    @pytest.mark.slow
-    def test_grouped_box_multiple_axes_ax_error(self, hist_df):
-        # GH 6970, GH 7069
-        df = hist_df
-        msg = "The number of passed axes must be 3, the same as the output plot"
-        with pytest.raises(ValueError, match=msg):
-            fig, axes = mpl.pyplot.subplots(2, 3)
-            # pass different number of axes from required
-            with tm.assert_produces_warning(UserWarning):
-                axes = df.groupby("classroom").boxplot(ax=axes)
-
-    def test_fontsize(self):
-        df = DataFrame({"a": [1, 2, 3, 4, 5, 6], "b": [0, 0, 0, 1, 1, 1]})
-        _check_ticks_props(
-            df.boxplot("a", by="b", fontsize=16), xlabelsize=16, ylabelsize=16
-        )
-
-    @pytest.mark.parametrize(
-        "col, expected_xticklabel",
-        [
-            ("v", ["(a, v)", "(b, v)", "(c, v)", "(d, v)", "(e, v)"]),
-            (["v"], ["(a, v)", "(b, v)", "(c, v)", "(d, v)", "(e, v)"]),
-            ("v1", ["(a, v1)", "(b, v1)", "(c, v1)", "(d, v1)", "(e, v1)"]),
-            (
-                ["v", "v1"],
-                [
-                    "(a, v)",
-                    "(a, v1)",
-                    "(b, v)",
-                    "(b, v1)",
-                    "(c, v)",
-                    "(c, v1)",
-                    "(d, v)",
-                    "(d, v1)",
-                    "(e, v)",
-                    "(e, v1)",
-                ],
-            ),
-            (
-                None,
-                [
-                    "(a, v)",
-                    "(a, v1)",
-                    "(b, v)",
-                    "(b, v1)",
-                    "(c, v)",
-                    "(c, v1)",
-                    "(d, v)",
-                    "(d, v1)",
-                    "(e, v)",
-                    "(e, v1)",
-                ],
-            ),
-        ],
-    )
-    def test_groupby_boxplot_subplots_false(self, col, expected_xticklabel):
-        # GH 16748
-        df = DataFrame(
-            {
-                "cat": np.random.default_rng(2).choice(list("abcde"), 100),
-                "v": np.random.default_rng(2).random(100),
-                "v1": np.random.default_rng(2).random(100),
-            }
-        )
-        grouped = df.groupby("cat")
-
-        axes = _check_plot_works(
-            grouped.boxplot, subplots=False, column=col, return_type="axes"
-        )
-
-        result_xticklabel = [x.get_text() for x in axes.get_xticklabels()]
-        assert expected_xticklabel == result_xticklabel
-
-    def test_groupby_boxplot_object(self, hist_df):
-        # GH 43480
-        df = hist_df.astype("object")
-        grouped = df.groupby("gender")
-        msg = "boxplot method requires numerical columns, nothing to plot"
-        with pytest.raises(ValueError, match=msg):
-            _check_plot_works(grouped.boxplot, subplots=False)
-
-    def test_boxplot_multiindex_column(self):
-        # GH 16748
-        arrays = [
-            ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
-            ["one", "two", "one", "two", "one", "two", "one", "two"],
-        ]
-        tuples = list(zip(*arrays))
-        index = MultiIndex.from_tuples(tuples, names=["first", "second"])
-        df = DataFrame(
-            np.random.default_rng(2).standard_normal((3, 8)),
-            index=["A", "B", "C"],
-            columns=index,
-        )
-
-        col = [("bar", "one"), ("bar", "two")]
-        axes = _check_plot_works(df.boxplot, column=col, return_type="axes")
-
-        expected_xticklabel = ["(bar, one)", "(bar, two)"]
-        result_xticklabel = [x.get_text() for x in axes.get_xticklabels()]
-        assert expected_xticklabel == result_xticklabel
diff --git a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/pip/_vendor/pygments/console.py b/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/pip/_vendor/pygments/console.py
deleted file mode 100644
index 8dd08abebce13dd43c7e5340e0f91d8c6cf400b4..0000000000000000000000000000000000000000
--- a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/pip/_vendor/pygments/console.py
+++ /dev/null
@@ -1,70 +0,0 @@
-"""
-    pygments.console
-    ~~~~~~~~~~~~~~~~
-
-    Format colored console output.
-
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-esc = "\x1b["
-
-codes = {}
-codes[""] = ""
-codes["reset"] = esc + "39;49;00m"
-
-codes["bold"] = esc + "01m"
-codes["faint"] = esc + "02m"
-codes["standout"] = esc + "03m"
-codes["underline"] = esc + "04m"
-codes["blink"] = esc + "05m"
-codes["overline"] = esc + "06m"
-
-dark_colors = ["black", "red", "green", "yellow", "blue",
-               "magenta", "cyan", "gray"]
-light_colors = ["brightblack", "brightred", "brightgreen", "brightyellow", "brightblue",
-                "brightmagenta", "brightcyan", "white"]
-
-x = 30
-for d, l in zip(dark_colors, light_colors):
-    codes[d] = esc + "%im" % x
-    codes[l] = esc + "%im" % (60 + x)
-    x += 1
-
-del d, l, x
-
-codes["white"] = codes["bold"]
-
-
-def reset_color():
-    return codes["reset"]
-
-
-def colorize(color_key, text):
-    return codes[color_key] + text + codes["reset"]
-
-
-def ansiformat(attr, text):
-    """
-    Format ``text`` with a color and/or some attributes::
-
-        color       normal color
-        *color*     bold color
-        _color_     underlined color
-        +color+     blinking color
-    """
-    result = []
-    if attr[:1] == attr[-1:] == '+':
-        result.append(codes['blink'])
-        attr = attr[1:-1]
-    if attr[:1] == attr[-1:] == '*':
-        result.append(codes['bold'])
-        attr = attr[1:-1]
-    if attr[:1] == attr[-1:] == '_':
-        result.append(codes['underline'])
-        attr = attr[1:-1]
-    result.append(codes[attr])
-    result.append(text)
-    result.append(codes['reset'])
-    return ''.join(result)
diff --git a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/toolz/tests/test_inspect_args.py b/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/toolz/tests/test_inspect_args.py
deleted file mode 100644
index 93408eb5f11664203dc7d2332ab1a549f5a935e1..0000000000000000000000000000000000000000
--- a/spaces/profayle/TerrapinTalk/myenv/lib/python3.9/site-packages/toolz/tests/test_inspect_args.py
+++ /dev/null
@@ -1,487 +0,0 @@
-import functools
-import inspect
-import itertools
-import operator
-import toolz
-from toolz.functoolz import (curry, is_valid_args, is_partial_args, is_arity,
-                             num_required_args, has_varargs, has_keywords)
-from toolz._signatures import builtins
-import toolz._signatures as _sigs
-from toolz.utils import raises
-
-
-def make_func(param_string, raise_if_called=True):
-    if not param_string.startswith('('):
-        param_string = '(%s)' % param_string
-    if raise_if_called:
-        body = 'raise ValueError("function should not be called")'
-    else:
-        body = 'return True'
-    d = {}
-    exec('def func%s:\n    %s' % (param_string, body), globals(), d)
-    return d['func']
-
-
-def test_make_func():
-    f = make_func('')
-    assert raises(ValueError, lambda: f())
-    assert raises(TypeError, lambda: f(1))
-
-    f = make_func('', raise_if_called=False)
-    assert f()
-    assert raises(TypeError, lambda: f(1))
-
-    f = make_func('x, y=1', raise_if_called=False)
-    assert f(1)
-    assert f(x=1)
-    assert f(1, 2)
-    assert f(x=1, y=2)
-    assert raises(TypeError, lambda: f(1, 2, 3))
-
-    f = make_func('(x, y=1)', raise_if_called=False)
-    assert f(1)
-    assert f(x=1)
-    assert f(1, 2)
-    assert f(x=1, y=2)
-    assert raises(TypeError, lambda: f(1, 2, 3))
-
-
-def test_is_valid(check_valid=is_valid_args, incomplete=False):
-    orig_check_valid = check_valid
-    check_valid = lambda func, *args, **kwargs: orig_check_valid(func, args, kwargs)
-
-    f = make_func('')
-    assert check_valid(f)
-    assert check_valid(f, 1) is False
-    assert check_valid(f, x=1) is False
-
-    f = make_func('x')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1)
-    assert check_valid(f, x=1)
-    assert check_valid(f, 1, x=2) is False
-    assert check_valid(f, 1, y=2) is False
-    assert check_valid(f, 1, 2) is False
-    assert check_valid(f, x=1, y=2) is False
-
-    f = make_func('x=1')
-    assert check_valid(f)
-    assert check_valid(f, 1)
-    assert check_valid(f, x=1)
-    assert check_valid(f, 1, x=2) is False
-    assert check_valid(f, 1, y=2) is False
-    assert check_valid(f, 1, 2) is False
-    assert check_valid(f, x=1, y=2) is False
-
-    f = make_func('*args')
-    assert check_valid(f)
-    assert check_valid(f, 1)
-    assert check_valid(f, 1, 2)
-    assert check_valid(f, x=1) is False
-
-    f = make_func('**kwargs')
-    assert check_valid(f)
-    assert check_valid(f, x=1)
-    assert check_valid(f, x=1, y=2)
-    assert check_valid(f, 1) is False
-
-    f = make_func('x, *args')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1)
-    assert check_valid(f, 1, 2)
-    assert check_valid(f, x=1)
-    assert check_valid(f, 1, x=1) is False
-    assert check_valid(f, 1, y=1) is False
-
-    f = make_func('x, y=1, **kwargs')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1)
-    assert check_valid(f, x=1)
-    assert check_valid(f, 1, 2)
-    assert check_valid(f, x=1, y=2, z=3)
-    assert check_valid(f, 1, 2, y=3) is False
-
-    f = make_func('a, b, c=3, d=4')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1) is incomplete
-    assert check_valid(f, 1, 2)
-    assert check_valid(f, 1, c=3) is incomplete
-    assert check_valid(f, 1, e=3) is False
-    assert check_valid(f, 1, 2, e=3) is False
-    assert check_valid(f, 1, 2, b=3) is False
-
-    assert check_valid(1) is False
-
-
-def test_is_valid_py3(check_valid=is_valid_args, incomplete=False):
-    orig_check_valid = check_valid
-    check_valid = lambda func, *args, **kwargs: orig_check_valid(func, args, kwargs)
-
-    f = make_func('x, *, y=1')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1)
-    assert check_valid(f, x=1)
-    assert check_valid(f, 1, y=2)
-    assert check_valid(f, 1, 2) is False
-    assert check_valid(f, 1, z=2) is False
-
-    f = make_func('x, *args, y=1')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1)
-    assert check_valid(f, x=1)
-    assert check_valid(f, 1, y=2)
-    assert check_valid(f, 1, 2, y=2)
-    assert check_valid(f, 1, 2)
-    assert check_valid(f, 1, z=2) is False
-
-    f = make_func('*, y=1')
-    assert check_valid(f)
-    assert check_valid(f, 1) is False
-    assert check_valid(f, y=1)
-    assert check_valid(f, z=1) is False
-
-    f = make_func('x, *, y')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1) is incomplete
-    assert check_valid(f, x=1) is incomplete
-    assert check_valid(f, 1, y=2)
-    assert check_valid(f, x=1, y=2)
-    assert check_valid(f, 1, 2) is False
-    assert check_valid(f, 1, z=2) is False
-    assert check_valid(f, 1, y=1, z=2) is False
-
-    f = make_func('x=1, *, y, z=3')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1, z=3) is incomplete
-    assert check_valid(f, y=2)
-    assert check_valid(f, 1, y=2)
-    assert check_valid(f, x=1, y=2)
-    assert check_valid(f, x=1, y=2, z=3)
-    assert check_valid(f, 1, x=1, y=2) is False
-    assert check_valid(f, 1, 3, y=2) is False
-
-    f = make_func('w, x=2, *args, y, z=4')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1) is incomplete
-    assert check_valid(f, 1, y=3)
-
-    f = make_func('a, b, c=3, d=4, *args, e=5, f=6, g, h')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1) is incomplete
-    assert check_valid(f, 1, 2) is incomplete
-    assert check_valid(f, 1, 2, g=7) is incomplete
-    assert check_valid(f, 1, 2, g=7, h=8)
-    assert check_valid(f, 1, 2, 3, 4, 5, 6, 7, 8, 9) is incomplete
-
-    f = make_func('a: int, b: float')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1) is incomplete
-    assert check_valid(f, b=1) is incomplete
-    assert check_valid(f, 1, 2)
-
-    f = make_func('(a: int, b: float) -> float')
-    assert check_valid(f) is incomplete
-    assert check_valid(f, 1) is incomplete
-    assert check_valid(f, b=1) is incomplete
-    assert check_valid(f, 1, 2)
-
-    f.__signature__ = 34
-    assert check_valid(f) is False
-
-    class RaisesValueError(object):
-        def __call__(self):
-            pass
-        @property
-        def __signature__(self):
-            raise ValueError('Testing Python 3.4')
-
-    f = RaisesValueError()
-    assert check_valid(f) is None
-
-
-def test_is_partial():
-    test_is_valid(check_valid=is_partial_args, incomplete=True)
-    test_is_valid_py3(check_valid=is_partial_args, incomplete=True)
-
-
-def test_is_valid_curry():
-    def check_curry(func, args, kwargs, incomplete=True):
-        try:
-            curry(func)(*args, **kwargs)
-            curry(func, *args)(**kwargs)
-            curry(func, **kwargs)(*args)
-            curry(func, *args, **kwargs)()
-            if not isinstance(func, type(lambda: None)):
-                return None
-            return incomplete
-        except ValueError:
-            return True
-        except TypeError:
-            return False
-
-    check_valid = functools.partial(check_curry, incomplete=True)
-    test_is_valid(check_valid=check_valid, incomplete=True)
-    test_is_valid_py3(check_valid=check_valid, incomplete=True)
-
-    check_valid = functools.partial(check_curry, incomplete=False)
-    test_is_valid(check_valid=check_valid, incomplete=False)
-    test_is_valid_py3(check_valid=check_valid, incomplete=False)
-
-
-def test_func_keyword():
-    def f(func=None):
-        pass
-    assert is_valid_args(f, (), {})
-    assert is_valid_args(f, (None,), {})
-    assert is_valid_args(f, (), {'func': None})
-    assert is_valid_args(f, (None,), {'func': None}) is False
-    assert is_partial_args(f, (), {})
-    assert is_partial_args(f, (None,), {})
-    assert is_partial_args(f, (), {'func': None})
-    assert is_partial_args(f, (None,), {'func': None}) is False
-
-
-def test_has_unknown_args():
-    assert has_varargs(1) is False
-    assert has_varargs(map)
-    assert has_varargs(make_func('')) is False
-    assert has_varargs(make_func('x, y, z')) is False
-    assert has_varargs(make_func('*args'))
-    assert has_varargs(make_func('**kwargs')) is False
-    assert has_varargs(make_func('x, y, *args, **kwargs'))
-    assert has_varargs(make_func('x, y, z=1')) is False
-    assert has_varargs(make_func('x, y, z=1, **kwargs')) is False
-
-    f = make_func('*args')
-    f.__signature__ = 34
-    assert has_varargs(f) is False
-
-    class RaisesValueError(object):
-        def __call__(self):
-            pass
-        @property
-        def __signature__(self):
-            raise ValueError('Testing Python 3.4')
-
-    f = RaisesValueError()
-    assert has_varargs(f) is None
-
-
-def test_num_required_args():
-    assert num_required_args(lambda: None) == 0
-    assert num_required_args(lambda x: None) == 1
-    assert num_required_args(lambda x, *args: None) == 1
-    assert num_required_args(lambda x, **kwargs: None) == 1
-    assert num_required_args(lambda x, y, *args, **kwargs: None) == 2
-    assert num_required_args(map) == 2
-    assert num_required_args(dict) is None
-
-
-def test_has_keywords():
-    assert has_keywords(lambda: None) is False
-    assert has_keywords(lambda x: None) is False
-    assert has_keywords(lambda x=1: None)
-    assert has_keywords(lambda **kwargs: None)
-    assert has_keywords(int)
-    assert has_keywords(sorted)
-    assert has_keywords(max)
-    assert has_keywords(map) is False
-    assert has_keywords(bytearray) is None
-
-
-def test_has_varargs():
-    assert has_varargs(lambda: None) is False
-    assert has_varargs(lambda *args: None)
-    assert has_varargs(lambda **kwargs: None) is False
-    assert has_varargs(map)
-    assert has_varargs(max) is None
-
-
-def test_is_arity():
-    assert is_arity(0, lambda: None)
-    assert is_arity(1, lambda: None) is False
-    assert is_arity(1, lambda x: None)
-    assert is_arity(3, lambda x, y, z: None)
-    assert is_arity(1, lambda x, *args: None) is False
-    assert is_arity(1, lambda x, **kwargs: None) is False
-    assert is_arity(1, all)
-    assert is_arity(2, map) is False
-    assert is_arity(2, range) is None
-
-
-def test_introspect_curry_valid_py3(check_valid=is_valid_args, incomplete=False):
-    orig_check_valid = check_valid
-    check_valid = lambda _func, *args, **kwargs: orig_check_valid(_func, args, kwargs)
-
-    f = toolz.curry(make_func('x, y, z=0'))
-    assert check_valid(f)
-    assert check_valid(f, 1)
-    assert check_valid(f, 1, 2)
-    assert check_valid(f, 1, 2, 3)
-    assert check_valid(f, 1, 2, 3, 4) is False
-    assert check_valid(f, invalid_keyword=True) is False
-    assert check_valid(f(1))
-    assert check_valid(f(1), 2)
-    assert check_valid(f(1), 2, 3)
-    assert check_valid(f(1), 2, 3, 4) is False
-    assert check_valid(f(1), x=2) is False
-    assert check_valid(f(1), y=2)
-    assert check_valid(f(x=1), 2) is False
-    assert check_valid(f(x=1), y=2)
-    assert check_valid(f(y=2), 1)
-    assert check_valid(f(y=2), 1, z=3)
-    assert check_valid(f(y=2), 1, 3) is False
-
-    f = toolz.curry(make_func('x, y, z=0'), 1, x=1)
-    assert check_valid(f) is False
-    assert check_valid(f, z=3) is False
-
-    f = toolz.curry(make_func('x, y, *args, z'))
-    assert check_valid(f)
-    assert check_valid(f, 0)
-    assert check_valid(f(1), 0)
-    assert check_valid(f(1, 2), 0)
-    assert check_valid(f(1, 2, 3), 0)
-    assert check_valid(f(1, 2, 3, 4), 0)
-    assert check_valid(f(1, 2, 3, 4), z=4)
-    assert check_valid(f(x=1))
-    assert check_valid(f(x=1), 1) is False
-    assert check_valid(f(x=1), y=2)
-
-
-def test_introspect_curry_partial_py3():
-    test_introspect_curry_valid_py3(check_valid=is_partial_args, incomplete=True)
-
-
-def test_introspect_curry_py3():
-    f = toolz.curry(make_func(''))
-    assert num_required_args(f) == 0
-    assert is_arity(0, f)
-    assert has_varargs(f) is False
-    assert has_keywords(f) is False
-
-    f = toolz.curry(make_func('x'))
-    assert num_required_args(f) == 0
-    assert is_arity(0, f) is False
-    assert is_arity(1, f) is False
-    assert has_varargs(f) is False
-    assert has_keywords(f)  # A side-effect of being curried
-
-    f = toolz.curry(make_func('x, y, z=0'))
-    assert num_required_args(f) == 0
-    assert is_arity(0, f) is False
-    assert is_arity(1, f) is False
-    assert is_arity(2, f) is False
-    assert is_arity(3, f) is False
-    assert has_varargs(f) is False
-    assert has_keywords(f)
-
-    f = toolz.curry(make_func('*args, **kwargs'))
-    assert num_required_args(f) == 0
-    assert has_varargs(f)
-    assert has_keywords(f)
-
-
-def test_introspect_builtin_modules():
-    mods = [builtins, functools, itertools, operator, toolz,
-            toolz.functoolz, toolz.itertoolz, toolz.dicttoolz, toolz.recipes]
-
-    denylist = set()
-
-    def add_denylist(mod, attr):
-        if hasattr(mod, attr):
-            denylist.add(getattr(mod, attr))
-
-    add_denylist(builtins, 'basestring')
-    add_denylist(builtins, 'NoneType')
-    add_denylist(builtins, '__metaclass__')
-    add_denylist(builtins, 'sequenceiterator')
-
-    def is_missing(modname, name, func):
-        if name.startswith('_') and not name.startswith('__'):
-            return False
-        if name.startswith('__pyx_unpickle_') or name.endswith('_cython__'):
-            return False
-        try:
-            if issubclass(func, BaseException):
-                return False
-        except TypeError:
-            pass
-        try:
-            return (callable(func)
-                    and func.__module__ is not None
-                    and modname in func.__module__
-                    and is_partial_args(func, (), {}) is not True
-                    and func not in denylist)
-        except AttributeError:
-            return False
-
-    missing = {}
-    for mod in mods:
-        modname = mod.__name__
-        for name, func in vars(mod).items():
-            if is_missing(modname, name, func):
-                if modname not in missing:
-                    missing[modname] = []
-                missing[modname].append(name)
-    if missing:
-        messages = []
-        for modname, names in sorted(missing.items()):
-            msg = '{}:\n    {}'.format(modname, '\n    '.join(sorted(names)))
-            messages.append(msg)
-        message = 'Missing introspection for the following callables:\n\n'
-        raise AssertionError(message + '\n\n'.join(messages))
-
-
-def test_inspect_signature_property():
-
-    # By adding AddX to our signature registry, we can inspect the class
-    # itself and objects of the class.  `inspect.signature` doesn't like
-    # it when `obj.__signature__` is a property.
-    class AddX(object):
-        def __init__(self, func):
-            self.func = func
-
-        def __call__(self, addx, *args, **kwargs):
-            return addx + self.func(*args, **kwargs)
-
-        @property
-        def __signature__(self):
-            sig = inspect.signature(self.func)
-            params = list(sig.parameters.values())
-            kind = inspect.Parameter.POSITIONAL_OR_KEYWORD
-            newparam = inspect.Parameter('addx', kind)
-            params = [newparam] + params
-            return sig.replace(parameters=params)
-
-    addx = AddX(lambda x: x)
-    sig = inspect.signature(addx)
-    assert sig == inspect.Signature(parameters=[
-        inspect.Parameter('addx', inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        inspect.Parameter('x', inspect.Parameter.POSITIONAL_OR_KEYWORD)])
-
-    assert num_required_args(AddX) is False
-    _sigs.signatures[AddX] = (_sigs.expand_sig((0, lambda func: None)),)
-    assert num_required_args(AddX) == 1
-    del _sigs.signatures[AddX]
-
-
-def test_inspect_wrapped_property():
-    class Wrapped(object):
-        def __init__(self, func):
-            self.func = func
-
-        def __call__(self, *args, **kwargs):
-            return self.func(*args, **kwargs)
-
-        @property
-        def __wrapped__(self):
-            return self.func
-
-    func = lambda x: x
-    wrapped = Wrapped(func)
-    assert inspect.signature(func) == inspect.signature(wrapped)
-
-    assert num_required_args(Wrapped) is None
-    _sigs.signatures[Wrapped] = (_sigs.expand_sig((0, lambda func: None)),)
-    assert num_required_args(Wrapped) == 1
diff --git a/spaces/quidiaMuxgu/Expedit-SAM/AutoDesk Autodesk Rendering 2005 X64 (64bit) (Product Key And Xforce Keygen).md b/spaces/quidiaMuxgu/Expedit-SAM/AutoDesk Autodesk Rendering 2005 X64 (64bit) (Product Key And Xforce Keygen).md
deleted file mode 100644
index 356b0ce78832600c9ab221909ff32f96bd99fbf3..0000000000000000000000000000000000000000
--- a/spaces/quidiaMuxgu/Expedit-SAM/AutoDesk Autodesk Rendering 2005 X64 (64bit) (Product Key And Xforce Keygen).md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>AutoDesk Autodesk Rendering 2005 X64 (64bit) (Product Key And Xforce Keygen)</h2><br /><p><b><b>Download File</b> &rArr; <a href="https://geags.com/2uCs9K">https://geags.com/2uCs9K</a></b></p><br /><br />
-<br />
-X force keygen autocad 2012 64 bit download music Jun 28, 2015 Autocad.... nastran in cad . ... Listen to Download Xforce Keygen Autodesk Rendering 2005 Keygen and 192 ... Download X-force 2019 - All Product key for Autodesk 2019 . 1fdad05405<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/quidiaMuxgu/Expedit-SAM/Download !!EXCLUSIVE!! Driver Mouse A4tech X7 F7.md b/spaces/quidiaMuxgu/Expedit-SAM/Download !!EXCLUSIVE!! Driver Mouse A4tech X7 F7.md
deleted file mode 100644
index 831729a130cae75553d51ccf2017a3de85916491..0000000000000000000000000000000000000000
--- a/spaces/quidiaMuxgu/Expedit-SAM/Download !!EXCLUSIVE!! Driver Mouse A4tech X7 F7.md	
+++ /dev/null
@@ -1,56 +0,0 @@
-
-<h1>Download Driver Mouse A4Tech X7 F7: How to Enhance Your Gaming Experience</h1>
-
-<p>If you are a gamer who wants to enjoy a smooth and precise control of your mouse, you need to download driver mouse A4Tech X7 F7. This is a software that allows you to customize the settings and functions of your A4Tech X7 F7 gaming mouse, which is one of the best mice for gaming. The A4Tech X7 F7 gaming mouse has a unique design that features a 3600 DPI laser engine, an ergonomic shape, a 5-mode switch button, a 16K onboard memory and a 6 DPI-shift ability. The mouse also has a special software called Oscar Editor, which enables you to create and store up to 58 macros in the mouse memory.</p>
-<h2>download driver mouse a4tech x7 f7</h2><br /><p><b><b>Download File</b> &raquo;&raquo;&raquo; <a href="https://geags.com/2uCrYf">https://geags.com/2uCrYf</a></b></p><br /><br />
-
-<p>In this article, we will show you how to download driver mouse A4Tech X7 F7 from the official website, how to install it on your computer, and how to use it to customize your mouse settings and functions.</p>
-
-<h2>How to Download Driver Mouse A4Tech X7 F7 from the Official Website?</h2>
-
-<p>The first step to download driver mouse A4Tech X7 F7 is to visit the official website of A4Tech, which is http://x7.a4tech.com/. On the homepage, you will see a drop-down list where you can select your model number. If you can't find your model number, you can click on the link below the list that says "click here to email us for further assistance". You will then be redirected to a contact form where you can fill in your details and request for the driver.</p>
-
-<p>Alternatively, you can browse by category and select "Mouse" from the menu. You will then see a list of different types of mice that A4Tech offers. You can scroll down until you find the "X7 OscarLite" section, where you will see the model number X77 / X87 / X89. This is the model number for the A4Tech X7 F7 gaming mouse. You can click on the "Download" button next to it and you will be taken to another page where you can choose your language and download the driver.</p>
-
-<p>The file name for the driver is lpksp1_nl-nl_x64.exe and it is about 200 MB in size. You will need to have Windows 7/8/8.1/10/11 (64bit) and a USB port to use this driver.</p>
-<p></p>
-
-<h2>How to Install Driver Mouse A4Tech X7 F7 on Your Computer?</h2>
-
-<p>After you download driver mouse A4Tech X7 F7 from the official website, you need to install it on your computer. To do this, follow these steps:</p>
-
-<ul>
-<li>Close all open programs on your computer.</li>
-<li>Double-click on the downloaded file and follow the instructions on the screen.</li>
-<li>Agree to the license terms and choose a location to extract the driver.</li>
-<li>The driver will be automatically installed on your computer.</li>
-<li>Restart your computer to apply the changes.</li>
-</ul>
-
-<p>After you install driver mouse A4Tech X7 F7 on your computer, you can open any of the A4Tech applications that are included in the driver package. These are:</p>
-
-<ul>
-<li>5-Mode Oscar Editor: This is a software that allows you to create and edit macros for your mouse. You can assign different functions and commands to each button of your mouse, such as keystrokes, mouse clicks, delays, loops and more. You can also adjust the sensitivity, speed and DPI of your mouse.</li>
-<li>Oscar Mouse Editor: This is another software that allows you to create and edit macros for your mouse. It has similar features as the 5-Mode Oscar Editor, but it also allows you to change the color and brightness of your mouse LED.</li>
-<li>Oscar Keyboard Editor: This is a software that allows you to create and edit macros for your keyboard. You can assign different functions and commands to each key of your keyboard, such as keystrokes, mouse clicks, delays, loops and more.</li>
-</ul>
-
-<h2>How to Use Driver Mouse A4Tech X7 F7 to Customize Your Mouse Settings and Functions?</h2>
-
-<p>Once you install driver mouse A4Tech X7 F7 on your computer, you can use it to customize your mouse settings and functions according to your preferences and needs. Here are some of the things you can do with driver mouse A4Tech X7 F7:</p>
-
-<ul>
-<li>You can switch between different modes of your mouse by pressing the 5-mode switch button on the side of your mouse. Each mode has a different color LED indicator and a different set of macros that you can create and edit with the Oscar Editor software.</li>
-<li>You can change the DPI of your mouse by pressing the DPI-shift button on top of your mouse. You can choose from six levels of DPI: 400 / 800 / 1200 / 1600 / 2000 / 3600. The higher the DPI, the faster and more sensitive your mouse cursor will move.</li>
-<li>You can store up to 58 macros in your mouse memory with the Oscar Editor software. You can assign these macros to any button of your mouse and use them in any game or application. You can also export or import macros from other users or devices.</li>
-<li>You can change the color and brightness of your mouse LED with the Oscar Mouse Editor software. You can choose from seven colors: red / green / blue / yellow / cyan / magenta / white. You can also adjust the brightness level from low / medium / high.</li>
-</ul>
-
-<h2>Conclusion</h2>
-
-<p>Download driver mouse A4Tech X7 F7 is a software that allows you to customize the settings and functions of your A4Tech X7 F7 gaming mouse, which is one of the best mice for gaming. The software enables you to create and edit macros for your mouse buttons, adjust the sensitivity, speed and DPI of your mouse cursor, change the color and brightness of your mouse LED, and switch between different modes of your mouse. The software is easy to download and install from the official website of A4Tech, and it works with Windows 7/8/8.1/10/11 (64bit) and a USB port. If you want to enhance your gaming experience with a smooth and precise control of your mouse, download driver mouse A4Tech X7 F7 today.</p>
-<p>Conclusion</p>
-
-<p>Download driver mouse A4Tech X7 F7 is a software that allows you to customize the settings and functions of your A4Tech X7 F7 gaming mouse, which is one of the best mice for gaming. The software enables you to create and edit macros for your mouse buttons, adjust the sensitivity, speed and DPI of your mouse cursor, change the color and brightness of your mouse LED, and switch between different modes of your mouse. The software is easy to download and install from the official website of A4Tech, and it works with Windows 7/8/8.1/10/11 (64bit) and a USB port. If you want to enhance your gaming experience with a smooth and precise control of your mouse, download driver mouse A4Tech X7 F7 today.</p> 3cee63e6c2<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/quidiaMuxgu/Expedit-SAM/HD Online Player (Season Of The Witch Full _TOP_ Movie With ).md b/spaces/quidiaMuxgu/Expedit-SAM/HD Online Player (Season Of The Witch Full _TOP_ Movie With ).md
deleted file mode 100644
index df97aa7e5014e597a04b39a3aed9e45f574bedc2..0000000000000000000000000000000000000000
--- a/spaces/quidiaMuxgu/Expedit-SAM/HD Online Player (Season Of The Witch Full _TOP_ Movie With ).md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<br />
-<p>For fans of 1950s-era cinema, a trip to the vintage exhibit at Universal movie theaters is a must. Sure, youve probably seen some of these on DVD, but to see them at a smaller scale on the big screen is a visceral pleasure, not to mention enlightening. <i>The Entity</i> is a good example of the type of movie that would have been staged at Universal in the era where theatergoing was a luxury and studios were happy to charge you the price of a meal. It makes for a surprisingly involving horror picture that operates at both the old-fashioned camp level, but also twists in the unexpected direction of darkness. It brings to mind the cosmic horror of H.P. Lovecraft in much the same way as the otherwise merely decent <i>House on Haunted Hill</i>. (If only it had ditched the last twenty minutes of lurid special effects!) Set in the Himmelsberg Mountains, the story follows a group of German climbers led by a prima donna-type woman (Jennifer Oland) who are pitted against an alien creature that has been terrorizing a nearby monastery. Through it all, Oland and her band of poser types kill with reckless abandon and try to save themselves at the expense of the good people they encounter along the way, all the while being manipulated by a mysterious figure on the mountain in league with the horror. The story is plotted with economy and meanness, a characteristic that also makes it more reflective of its era than most contemporary genre productions. <i>Benjamin Vershure</i></p>
-<p>Before <i>Evil Dead</i>, <i>I Spit on Your Grave</i> or <i>Sleeping Beauties</i>, <i>Broken Dolls</i> perfectly captured the sensation of sitting on a toilet in the dark and suddenly finding yourself with your face in the bowl watching a newscaster report on 9/11. The way the film slows down the action to an unnerving crawl and crams characters into such intimate space is a perfect showcase for both slasher heroine (Tricia Vessey) and the hapless stoner who picks up her trail. The grainy black-and-white photography is ironically reminiscent of the era of horror cinema that is being salvaged by the likes of <i>The Babadook</i>, <i>The Witch</i> and <i>The Exorcism of Emily Rose</i>. The whole thing feels like watching it on VHS at your friends house (which it feels like you were, at least briefly), which is perfectly apt for the ghosts-in-the-woods vibe of the premise. <i>Dana Barbuto</i><br class=clear /></p>
-<h2>HD Online Player (Season Of The Witch full movie with )</h2><br /><p><b><b>DOWNLOAD</b> &#10042;&#10042;&#10042; <a href="https://geags.com/2uCq7E">https://geags.com/2uCq7E</a></b></p><br /><br /> 899543212b<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/quidiaMuxgu/Expedit-SAM/Hooverphonic Orchestra Torrent Full.md b/spaces/quidiaMuxgu/Expedit-SAM/Hooverphonic Orchestra Torrent Full.md
deleted file mode 100644
index bd7074b56fa099daa1f718aedf43e637db92174a..0000000000000000000000000000000000000000
--- a/spaces/quidiaMuxgu/Expedit-SAM/Hooverphonic Orchestra Torrent Full.md	
+++ /dev/null
@@ -1,22 +0,0 @@
-<h2>hooverphonic orchestra torrent Full</h2><br /><p><b><b>Download File</b> &#10022;&#10022;&#10022; <a href="https://geags.com/2uCqsw">https://geags.com/2uCqsw</a></b></p><br /><br />
-<br />
-The Night Before (with Orchestra), Reflection, and In Wonderland are three orchestral works composed by the American composer Nico Muhly in the 2010s. They are the first works in the "Babies" trilogy (the second, "The Trouble with Being Born" (2013) and the third, "I Am the Bulldog (The Original)" (2018) are in progress).
-
-Overview
-
-Muhly's "Babies" trilogy is concerned with his experience of growing up and his place within his family, first in America, then in Israel. The first two works in the series, "The Night Before" (2010) and "The Trouble with Being Born" (2013) are long narrative works with a structure similar to that of "Symphony No. 1" (2000), his first composition. Muhly's "Babies" trilogy also shares characteristics with his works for dance, for example the use of rhythms derived from Eastern European folk music.
-
-In 2014, Muhly commented on the impact of children on his work:
-
-Roles and structure
-
-"The Night Before"
-
-"The Night Before" (2010) is a solo work for viola, an instrument which had not been used by Muhly in any of his previous compositions. It is scored for a large orchestra, but it also has a solo part for the viola player, who may play both in unison and in counterpoint with the orchestra. The viola part can also be played in unison with other solo players, including the cello, and even with the pianist.
-
-"The Night Before" begins with the solo viola player playing a song. As the orchestra begins to play, the viola player hears her violinist brother playing the same song. He plays it in the same way as she did, as a duet. Over the course of the piece, the viola player listens to more songs from her brother, eventually hearing a duet performed by her parents. As she listens, she becomes increasingly agitated, starting to cry, and eventually enters a trance. The piece ends with a slowed-down version of the beginning; the viola player has heard a new song, which she now sings to her brother, but in a different way.
-
-"The Night Before" is structured as a set of six scenes, the last of which is made up of the beginning and the end, though only the last is explicitly stated. Muhly described 4fefd39f24<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/r3gm/RVC_HF/lib/infer_pack/modules.py b/spaces/r3gm/RVC_HF/lib/infer_pack/modules.py
deleted file mode 100644
index c83289df7c79a4810dacd15c050148544ba0b6a9..0000000000000000000000000000000000000000
--- a/spaces/r3gm/RVC_HF/lib/infer_pack/modules.py
+++ /dev/null
@@ -1,522 +0,0 @@
-import copy
-import math
-import numpy as np
-import scipy
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm
-
-from lib.infer_pack import commons
-from lib.infer_pack.commons import init_weights, get_padding
-from lib.infer_pack.transforms import piecewise_rational_quadratic_transform
-
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
-    def __init__(self, channels, eps=1e-5):
-        super().__init__()
-        self.channels = channels
-        self.eps = eps
-
-        self.gamma = nn.Parameter(torch.ones(channels))
-        self.beta = nn.Parameter(torch.zeros(channels))
-
-    def forward(self, x):
-        x = x.transpose(1, -1)
-        x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
-        return x.transpose(1, -1)
-
-
-class ConvReluNorm(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        hidden_channels,
-        out_channels,
-        kernel_size,
-        n_layers,
-        p_dropout,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.hidden_channels = hidden_channels
-        self.out_channels = out_channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.p_dropout = p_dropout
-        assert n_layers > 1, "Number of layers should be larger than 0."
-
-        self.conv_layers = nn.ModuleList()
-        self.norm_layers = nn.ModuleList()
-        self.conv_layers.append(
-            nn.Conv1d(
-                in_channels, hidden_channels, kernel_size, padding=kernel_size // 2
-            )
-        )
-        self.norm_layers.append(LayerNorm(hidden_channels))
-        self.relu_drop = nn.Sequential(nn.ReLU(), nn.Dropout(p_dropout))
-        for _ in range(n_layers - 1):
-            self.conv_layers.append(
-                nn.Conv1d(
-                    hidden_channels,
-                    hidden_channels,
-                    kernel_size,
-                    padding=kernel_size // 2,
-                )
-            )
-            self.norm_layers.append(LayerNorm(hidden_channels))
-        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-        self.proj.weight.data.zero_()
-        self.proj.bias.data.zero_()
-
-    def forward(self, x, x_mask):
-        x_org = x
-        for i in range(self.n_layers):
-            x = self.conv_layers[i](x * x_mask)
-            x = self.norm_layers[i](x)
-            x = self.relu_drop(x)
-        x = x_org + self.proj(x)
-        return x * x_mask
-
-
-class DDSConv(nn.Module):
-    """
-    Dialted and Depth-Separable Convolution
-    """
-
-    def __init__(self, channels, kernel_size, n_layers, p_dropout=0.0):
-        super().__init__()
-        self.channels = channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.p_dropout = p_dropout
-
-        self.drop = nn.Dropout(p_dropout)
-        self.convs_sep = nn.ModuleList()
-        self.convs_1x1 = nn.ModuleList()
-        self.norms_1 = nn.ModuleList()
-        self.norms_2 = nn.ModuleList()
-        for i in range(n_layers):
-            dilation = kernel_size**i
-            padding = (kernel_size * dilation - dilation) // 2
-            self.convs_sep.append(
-                nn.Conv1d(
-                    channels,
-                    channels,
-                    kernel_size,
-                    groups=channels,
-                    dilation=dilation,
-                    padding=padding,
-                )
-            )
-            self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
-            self.norms_1.append(LayerNorm(channels))
-            self.norms_2.append(LayerNorm(channels))
-
-    def forward(self, x, x_mask, g=None):
-        if g is not None:
-            x = x + g
-        for i in range(self.n_layers):
-            y = self.convs_sep[i](x * x_mask)
-            y = self.norms_1[i](y)
-            y = F.gelu(y)
-            y = self.convs_1x1[i](y)
-            y = self.norms_2[i](y)
-            y = F.gelu(y)
-            y = self.drop(y)
-            x = x + y
-        return x * x_mask
-
-
-class WN(torch.nn.Module):
-    def __init__(
-        self,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        gin_channels=0,
-        p_dropout=0,
-    ):
-        super(WN, self).__init__()
-        assert kernel_size % 2 == 1
-        self.hidden_channels = hidden_channels
-        self.kernel_size = (kernel_size,)
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.gin_channels = gin_channels
-        self.p_dropout = p_dropout
-
-        self.in_layers = torch.nn.ModuleList()
-        self.res_skip_layers = torch.nn.ModuleList()
-        self.drop = nn.Dropout(p_dropout)
-
-        if gin_channels != 0:
-            cond_layer = torch.nn.Conv1d(
-                gin_channels, 2 * hidden_channels * n_layers, 1
-            )
-            self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name="weight")
-
-        for i in range(n_layers):
-            dilation = dilation_rate**i
-            padding = int((kernel_size * dilation - dilation) / 2)
-            in_layer = torch.nn.Conv1d(
-                hidden_channels,
-                2 * hidden_channels,
-                kernel_size,
-                dilation=dilation,
-                padding=padding,
-            )
-            in_layer = torch.nn.utils.weight_norm(in_layer, name="weight")
-            self.in_layers.append(in_layer)
-
-            # last one is not necessary
-            if i < n_layers - 1:
-                res_skip_channels = 2 * hidden_channels
-            else:
-                res_skip_channels = hidden_channels
-
-            res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
-            res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name="weight")
-            self.res_skip_layers.append(res_skip_layer)
-
-    def forward(self, x, x_mask, g=None, **kwargs):
-        output = torch.zeros_like(x)
-        n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
-        if g is not None:
-            g = self.cond_layer(g)
-
-        for i in range(self.n_layers):
-            x_in = self.in_layers[i](x)
-            if g is not None:
-                cond_offset = i * 2 * self.hidden_channels
-                g_l = g[:, cond_offset : cond_offset + 2 * self.hidden_channels, :]
-            else:
-                g_l = torch.zeros_like(x_in)
-
-            acts = commons.fused_add_tanh_sigmoid_multiply(x_in, g_l, n_channels_tensor)
-            acts = self.drop(acts)
-
-            res_skip_acts = self.res_skip_layers[i](acts)
-            if i < self.n_layers - 1:
-                res_acts = res_skip_acts[:, : self.hidden_channels, :]
-                x = (x + res_acts) * x_mask
-                output = output + res_skip_acts[:, self.hidden_channels :, :]
-            else:
-                output = output + res_skip_acts
-        return output * x_mask
-
-    def remove_weight_norm(self):
-        if self.gin_channels != 0:
-            torch.nn.utils.remove_weight_norm(self.cond_layer)
-        for l in self.in_layers:
-            torch.nn.utils.remove_weight_norm(l)
-        for l in self.res_skip_layers:
-            torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
-        super(ResBlock1, self).__init__()
-        self.convs1 = nn.ModuleList(
-            [
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[0],
-                        padding=get_padding(kernel_size, dilation[0]),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[1],
-                        padding=get_padding(kernel_size, dilation[1]),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[2],
-                        padding=get_padding(kernel_size, dilation[2]),
-                    )
-                ),
-            ]
-        )
-        self.convs1.apply(init_weights)
-
-        self.convs2 = nn.ModuleList(
-            [
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=1,
-                        padding=get_padding(kernel_size, 1),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=1,
-                        padding=get_padding(kernel_size, 1),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=1,
-                        padding=get_padding(kernel_size, 1),
-                    )
-                ),
-            ]
-        )
-        self.convs2.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c1, c2 in zip(self.convs1, self.convs2):
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c1(xt)
-            xt = F.leaky_relu(xt, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c2(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs1:
-            remove_weight_norm(l)
-        for l in self.convs2:
-            remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
-        super(ResBlock2, self).__init__()
-        self.convs = nn.ModuleList(
-            [
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[0],
-                        padding=get_padding(kernel_size, dilation[0]),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[1],
-                        padding=get_padding(kernel_size, dilation[1]),
-                    )
-                ),
-            ]
-        )
-        self.convs.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c in self.convs:
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs:
-            remove_weight_norm(l)
-
-
-class Log(nn.Module):
-    def forward(self, x, x_mask, reverse=False, **kwargs):
-        if not reverse:
-            y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
-            logdet = torch.sum(-y, [1, 2])
-            return y, logdet
-        else:
-            x = torch.exp(x) * x_mask
-            return x
-
-
-class Flip(nn.Module):
-    def forward(self, x, *args, reverse=False, **kwargs):
-        x = torch.flip(x, [1])
-        if not reverse:
-            logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
-            return x, logdet
-        else:
-            return x
-
-
-class ElementwiseAffine(nn.Module):
-    def __init__(self, channels):
-        super().__init__()
-        self.channels = channels
-        self.m = nn.Parameter(torch.zeros(channels, 1))
-        self.logs = nn.Parameter(torch.zeros(channels, 1))
-
-    def forward(self, x, x_mask, reverse=False, **kwargs):
-        if not reverse:
-            y = self.m + torch.exp(self.logs) * x
-            y = y * x_mask
-            logdet = torch.sum(self.logs * x_mask, [1, 2])
-            return y, logdet
-        else:
-            x = (x - self.m) * torch.exp(-self.logs) * x_mask
-            return x
-
-
-class ResidualCouplingLayer(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        p_dropout=0,
-        gin_channels=0,
-        mean_only=False,
-    ):
-        assert channels % 2 == 0, "channels should be divisible by 2"
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.half_channels = channels // 2
-        self.mean_only = mean_only
-
-        self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
-        self.enc = WN(
-            hidden_channels,
-            kernel_size,
-            dilation_rate,
-            n_layers,
-            p_dropout=p_dropout,
-            gin_channels=gin_channels,
-        )
-        self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
-        self.post.weight.data.zero_()
-        self.post.bias.data.zero_()
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
-        h = self.pre(x0) * x_mask
-        h = self.enc(h, x_mask, g=g)
-        stats = self.post(h) * x_mask
-        if not self.mean_only:
-            m, logs = torch.split(stats, [self.half_channels] * 2, 1)
-        else:
-            m = stats
-            logs = torch.zeros_like(m)
-
-        if not reverse:
-            x1 = m + x1 * torch.exp(logs) * x_mask
-            x = torch.cat([x0, x1], 1)
-            logdet = torch.sum(logs, [1, 2])
-            return x, logdet
-        else:
-            x1 = (x1 - m) * torch.exp(-logs) * x_mask
-            x = torch.cat([x0, x1], 1)
-            return x
-
-    def remove_weight_norm(self):
-        self.enc.remove_weight_norm()
-
-
-class ConvFlow(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        filter_channels,
-        kernel_size,
-        n_layers,
-        num_bins=10,
-        tail_bound=5.0,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.num_bins = num_bins
-        self.tail_bound = tail_bound
-        self.half_channels = in_channels // 2
-
-        self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
-        self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.0)
-        self.proj = nn.Conv1d(
-            filter_channels, self.half_channels * (num_bins * 3 - 1), 1
-        )
-        self.proj.weight.data.zero_()
-        self.proj.bias.data.zero_()
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
-        h = self.pre(x0)
-        h = self.convs(h, x_mask, g=g)
-        h = self.proj(h) * x_mask
-
-        b, c, t = x0.shape
-        h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2)  # [b, cx?, t] -> [b, c, t, ?]
-
-        unnormalized_widths = h[..., : self.num_bins] / math.sqrt(self.filter_channels)
-        unnormalized_heights = h[..., self.num_bins : 2 * self.num_bins] / math.sqrt(
-            self.filter_channels
-        )
-        unnormalized_derivatives = h[..., 2 * self.num_bins :]
-
-        x1, logabsdet = piecewise_rational_quadratic_transform(
-            x1,
-            unnormalized_widths,
-            unnormalized_heights,
-            unnormalized_derivatives,
-            inverse=reverse,
-            tails="linear",
-            tail_bound=self.tail_bound,
-        )
-
-        x = torch.cat([x0, x1], 1) * x_mask
-        logdet = torch.sum(logabsdet * x_mask, [1, 2])
-        if not reverse:
-            return x, logdet
-        else:
-            return x
diff --git a/spaces/radames/UserControllableLT-Latent-Transformer/interface/pixel2style2pixel/scripts/calc_losses_on_images.py b/spaces/radames/UserControllableLT-Latent-Transformer/interface/pixel2style2pixel/scripts/calc_losses_on_images.py
deleted file mode 100644
index 436348db28a625d94f63bbb86ff779b92d28b419..0000000000000000000000000000000000000000
--- a/spaces/radames/UserControllableLT-Latent-Transformer/interface/pixel2style2pixel/scripts/calc_losses_on_images.py
+++ /dev/null
@@ -1,84 +0,0 @@
-from argparse import ArgumentParser
-import os
-import json
-import sys
-from tqdm import tqdm
-import numpy as np
-import torch
-from torch.utils.data import DataLoader
-import torchvision.transforms as transforms
-
-sys.path.append(".")
-sys.path.append("..")
-
-from criteria.lpips.lpips import LPIPS
-from datasets.gt_res_dataset import GTResDataset
-
-
-def parse_args():
-	parser = ArgumentParser(add_help=False)
-	parser.add_argument('--mode', type=str, default='lpips', choices=['lpips', 'l2'])
-	parser.add_argument('--data_path', type=str, default='results')
-	parser.add_argument('--gt_path', type=str, default='gt_images')
-	parser.add_argument('--workers', type=int, default=4)
-	parser.add_argument('--batch_size', type=int, default=4)
-	args = parser.parse_args()
-	return args
-
-
-def run(args):
-
-	transform = transforms.Compose([transforms.Resize((256, 256)),
-									transforms.ToTensor(),
-									transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])
-
-	print('Loading dataset')
-	dataset = GTResDataset(root_path=args.data_path,
-	                       gt_dir=args.gt_path,
-						   transform=transform)
-
-	dataloader = DataLoader(dataset,
-	                        batch_size=args.batch_size,
-	                        shuffle=False,
-	                        num_workers=int(args.workers),
-	                        drop_last=True)
-
-	if args.mode == 'lpips':
-		loss_func = LPIPS(net_type='alex')
-	elif args.mode == 'l2':
-		loss_func = torch.nn.MSELoss()
-	else:
-		raise Exception('Not a valid mode!')
-	loss_func.cuda()
-
-	global_i = 0
-	scores_dict = {}
-	all_scores = []
-	for result_batch, gt_batch in tqdm(dataloader):
-		for i in range(args.batch_size):
-			loss = float(loss_func(result_batch[i:i+1].cuda(), gt_batch[i:i+1].cuda()))
-			all_scores.append(loss)
-			im_path = dataset.pairs[global_i][0]
-			scores_dict[os.path.basename(im_path)] = loss
-			global_i += 1
-
-	all_scores = list(scores_dict.values())
-	mean = np.mean(all_scores)
-	std = np.std(all_scores)
-	result_str = 'Average loss is {:.2f}+-{:.2f}'.format(mean, std)
-	print('Finished with ', args.data_path)
-	print(result_str)
-
-	out_path = os.path.join(os.path.dirname(args.data_path), 'inference_metrics')
-	if not os.path.exists(out_path):
-		os.makedirs(out_path)
-
-	with open(os.path.join(out_path, 'stat_{}.txt'.format(args.mode)), 'w') as f:
-		f.write(result_str)
-	with open(os.path.join(out_path, 'scores_{}.json'.format(args.mode)), 'w') as f:
-		json.dump(scores_dict, f)
-
-
-if __name__ == '__main__':
-	args = parse_args()
-	run(args)
diff --git a/spaces/raedeXanto/academic-chatgpt-beta/Busywin 14 Rel 6 1 Crack 12 les tmoignages des utilisateurs satisfaits.md b/spaces/raedeXanto/academic-chatgpt-beta/Busywin 14 Rel 6 1 Crack 12 les tmoignages des utilisateurs satisfaits.md
deleted file mode 100644
index 607864ac62c2f595e733e4dcd45e5b15b65cd3b9..0000000000000000000000000000000000000000
--- a/spaces/raedeXanto/academic-chatgpt-beta/Busywin 14 Rel 6 1 Crack 12 les tmoignages des utilisateurs satisfaits.md	
+++ /dev/null
@@ -1,156 +0,0 @@
-<br />
-<h1>What is Busywin and why you need it</h1>
-<p>If you are looking for a powerful and easy-to-use accounting software for your business, you might have heard of Busywin. Busywin is a GST-ready business accounting software in India with over 1 million customers worldwide. It helps businesses and enterprises in GST billing, accounting, inventory management, order processing, E-way bill, GSTR reconciliation, and more. It also has advanced features like multi-currency, multi-location, multi-branch, multi-godown, party-wise pricing, quotation, etc.</p>
-<p>Busywin is designed to simplify your business processes and make them more efficient and accurate. You can generate various reports and documents with Busywin, such as invoices, vouchers, letters, sales tax reports, VAT reports, service tax reports, TDS reports, FBT reports, etc. You can also send them by email or SMS to your clients or customers. Busywin also has a mobile app for Android users, which allows you to track your accounting data on the go.</p>
-<h2>busywin 14 rel 6 1 crack 12</h2><br /><p><b><b>Download File</b> &#10084;&#10084;&#10084; <a href="https://tinourl.com/2uL2gJ">https://tinourl.com/2uL2gJ</a></b></p><br /><br />
-<p>Busywin is available in different editions and versions to suit your needs and budget. You can choose from Basic Edition, Standard Edition, Enterprise Edition, or Corporate Edition. You can also choose from different versions such as Busywin 12, Busywin 14, Busywin 16, Busywin 18, etc. The latest version is Busywin 21 (rel 8.5), which was released on April 13th, 2023.</p>
-<p>In this article, we will focus on Busywin 14 rel 6.1, which is one of the most popular versions of Busywin. We will show you how to download and install it on your PC, how to crack it to use it for free, how to use it after cracking it, and what are the benefits of using it.</p>
- <h2>How to download and install Busywin 14 rel 6.1</h2>
-<p>The first step to use Busywin 14 rel 6.1 is to download and install it on your PC. Here are the steps to do that:</p>
-<ol>
-<li>Go to the official website of Busywin at <a href="http://busywin.com/">http://busywin.com/</a> and click on the "Download" section.</li>
-<li>Select "Busywin" from the product list and choose "Busy (Rel 6.1)" from the version list.</li>
-<li>Click on the "Download" button and save the file on your PC.</li>
-<li>Double-click on the downloaded file and follow the instructions to install Busywin on your PC.</li>
-<li>After the installation is complete, launch Busywin from your desktop or start menu.</li>
-</ol>
-<p>You will see a screen like this:</p>
-<img src="https://i.imgur.com/4f0q9ZS.png" alt="Busywin activation screen">
-<p>This screen shows that you need to activate Busywin before you can use it. You can either buy a license key from the official website or use a crack method to bypass the activation process.</p>
- <h2>How to crack Busywin 14 rel 6.1</h2>
-<p>Before we show you how to crack Busywin 14 rel 6.1, we want to give you a disclaimer and a warning. Cracking software is illegal and unethical. It violates the intellectual property rights of the software developers and may expose your PC to viruses or malware. It may also cause errors or glitches in the software performance or functionality. We do not recommend or endorse cracking software in any way. We are only providing this information for educational purposes only. Use it at your own risk.</p>
-<p>There are three main methods to crack Busywin 14 rel 6.1: using a patch file, using a keygen file, or using a serial key. We will explain each method below:</p>
- <h3>Method 1: Using a patch file</h3>
-<p>A patch file is a small program that modifies the original files of Busywin to bypass the activation process. Here are the steps to use a patch file:</p>
-<p>busywin 14 rel 6 1 patch download<br />
-busywin 14 rel 6 1 activation key<br />
-busywin 14 rel 6 1 full version free<br />
-busywin 14 rel 6 1 serial number<br />
-busywin 14 rel 6 1 license code<br />
-busywin 14 rel 6 1 crack file<br />
-busywin 14 rel 6 1 software update<br />
-busywin 14 rel 6 1 installation guide<br />
-busywin 14 rel 6 1 system requirements<br />
-busywin 14 rel 6 1 features and benefits<br />
-busywin 14 rel 6 1 price and plans<br />
-busywin 14 rel 6 1 customer reviews<br />
-busywin 14 rel 6 1 alternatives and competitors<br />
-busywin 14 rel 6 1 support and help<br />
-busywin 14 rel 6 1 tutorial and tips<br />
-busywin 14 rel 6.1 crack with gst<br />
-busywin crack for gst version download<br />
-how to crack busywin software for free<br />
-busy accounting software crack download for pc<br />
-busy software latest version with crack<br />
-busy software crack password reset<br />
-how to use busy software without license<br />
-busy software error solution and fix<br />
-how to backup and restore data in busy software<br />
-how to import and export data in busy software<br />
-how to customize invoice and reports in busy software<br />
-how to create ledger and voucher in busy software<br />
-how to manage inventory and stock in busy software<br />
-how to apply tax and discount in busy software<br />
-how to generate gst reports and returns in busy software<br />
-how to reconcile bank and cash transactions in busy software<br />
-how to set up multi-user and multi-company in busy software<br />
-how to secure data and access rights in busy software<br />
-how to integrate busy software with other applications<br />
-how to upgrade and migrate data in busy software<br />
-best accounting software for small business in india<br />
-comparison of tally erp and busy accounting software<br />
-advantages and disadvantages of using cracked software<br />
-risks and consequences of using pirated software<br />
-legal and ethical issues of software piracy<br />
-how to avoid software piracy and protect your rights<br />
-how to report software piracy and get rewarded<br />
-benefits of using genuine and licensed software<br />
-how to get free trial and demo of busy software<br />
-how to buy and renew license of busy software online<br />
-how to get discounts and offers on busy software purchase<br />
-how to find authorized dealers and distributors of busy software near me <br />
-how to contact busy infotech pvt ltd for queries and complaints <br />
-how to join busy infotech partner program and earn commissions <br />
-how to learn more about accounting and gst with busy infotech academy</p>
-<ol>
-<li>Download a patch file for Busywin 14 rel 6.1 from a reliable source on the internet.</li>
-<li>Extract the patch file from the zip or rar archive and copy it to the installation folder of Busywin (usually C:\Program Files\BusyWin).</li>
-<li>Right-click on the patch file and select "Run as administrator".</li>
-<li>Click on the "Patch" button and wait for the process to complete.</li>
-<li>Launch Busywin from your desktop or start menu.</li>
-</ol>
-<p>You will see a screen like this:</p>
-<img src="https://i.imgur.com/9gQwZ0L.png" alt="Busywin cracked screen">
-<p>This screen shows that you have successfully cracked Busywin 14 rel 6.1 using a patch file.</p>
- <h3>Method 2: Using a keygen file</h3>
-<p>A keygen file is a small program that generates random license keys for Busywin that can be used to activate it. Here are the steps to use a keygen file:</p>
-<ol>
-<li>Download a keygen file for Busywin 14 rel 6.1 from a reliable source on the internet.</li>
-<li>Extract the keygen file from the zip or rar archive and run it on your PC.</li>
-<li>Select "Busy (Rel 6)" from the product list and click on the "Generate" button.</li>
-<li>Copy the license key that appears on the screen.</li>
-<li>Launch Busywin from your desktop or start menu.</li>
-<li>Paste the license key in the activation screen and click on "Activate".</li>
-</ol>
-<p>You will see a screen like this:</p>
-<img src="https://i.imgur.com/9gQwZ0L.png" alt="Busywin cracked screen">
-<p>This screen shows that you have successfully cracked Busywin 14 rel 6.1 using a keygen file.</p>
- <h3>Method 3: Using a serial key</h3>
-<p>A serial key is a pre-generated license key for Busywin that can be used to activate it without using any program. Here are the steps to use a serial key:</p>
-<ol>
-<li>Find a serial key for Busywin 14 rel 6.1 from a reliable source on the internet.</li>
-<li>Launch Busywin from your desktop or start menu.</li>
-<li>Paste the serial key in the activation screen and click on "Activate".</li>
-</ol>
-<p>You will see a screen like this:</p>
-<img src="https://i.imgur.com/9gQwZ0L.png" alt="Busywin cracked screen">
-<p>This screen shows that you have successfully cracked Busywin 14 rel 6.1 using a serial key.</p>
- <h2>How to use Busywin 14 rel 6.1 after cracking it</h2>
-<p>After cracking Busywin 14 rel 6.1 using any of the methods above, you can use it as if you have bought it legally. You can access all its features and functions without any limitations or restrictions.</p>
-<p>To use Busywin effectively, here are some tips and tricks that you should know:</p>
- <ul>
- <li>To create a new company in Busywin, go to File > New Company > Enter Company Name > Select Country > Select State > Select City > Enter Address > Enter Phone Number > Enter Email ID > Enter GSTIN > Click OK.</li>
- <li>To open an existing company in Busy <ul>
- <li>To create a new company in Busywin, go to File > New Company > Enter Company Name > Select Country > Select State > Select City > Enter Address > Enter Phone Number > Enter Email ID > Enter GSTIN > Click OK.</li>
- <li>To open an existing company in Busywin, go to File > Open Company > Select Company Name > Click OK.</li>
- <li>To switch between companies in Busywin, go to File > Switch Company > Select Company Name > Click OK.</li>
- <li>To create a new voucher in Busywin, go to Voucher Entry > Select Voucher Type (Sale, Purchase, Payment, Receipt, Journal, etc.) > Enter Voucher Date > Enter Voucher Number > Enter Party Name > Enter Item Details > Enter Amount Details > Click Save.</li>
- <li>To edit or delete a voucher in Busywin, go to Display > Day Book > Select Voucher Date > Select Voucher Type > Select Voucher Number > Press F2 for Edit or F3 for Delete.</li>
- <li>To print a voucher in Busywin, go to Display > Day Book > Select Voucher Date > Select Voucher Type > Select Voucher Number > Press F5 for Print.</li>
- <li>To create a new ledger account in Busywin, go to Master Creation/Alteration/Delete/Display/Print/Import/Export/Rebuild Indexes/Rebuild Data/Rebuild All Data/Rebuild All Data (Forcefully) (M)enu (M)aster (A)ccounts (C)reate (A)ccounts. Enter Account Name, Account Group, Opening Balance, and other details. Click Save.</li>
- <li>To edit or delete a ledger account in Busywin, go to Master Creation/Alteration/Delete/Display/Print/Import/Export/Rebuild Indexes/Rebuild Data/Rebuild All Data/Rebuild All Data (Forcefully) (M)enu (M)aster (A)ccounts (A)lteration/(D)eletion. Select Account Name and press F2 for Edit or F3 for Delete.</li>
- <li>To print a ledger account in Busywin, go to Display > Account Books/Ledgers/Trial Balance/Balance Sheet/P&L A/c/Cash Flow/Fund Flow/Ratio Analysis/Bank Reconciliation Statement/Multi Columnar Reports/Multi Columnar Reports with Graphs/Multi Columnar Reports with Graphs & Narrations/Multi Columnar Reports with Narrations/Multi Columnar Reports with Narrations & Graphs/Multi Columnar Reports with Narrations & Graphs & Narrations/Multi Columnar Reports with Narrations & Graphs & Narrations & Graphs/Multi Columnar Reports with Narrations & Graphs & Narrations & Graphs & Narrations/Multi Columnar Reports with Narrations & Graphs & Narrations & Graphs & Narrations & Graphs/Multi Columnar Reports with Narrations & Graphs & Narrations & Graphs & Narrations & Graphs & Narrations/Multi Columnar Reports with Narrations & Graphs & Narrations & Graphs & Narrations & Graphs & Narrations & Graphs/Multi Columnar Reports with Narrations & Graphs & Narrations & Graphs & Narrations & Graphs & Narrations & Graphs & Narrations. Select Account Name and press F5 for Print.</li>
- <li>To create a new item master in Busywin, go to Master Creation/Alteration/Delete/Display/Print/Import/Export/Rebuild Indexes/Rebuild Data/Rebuild All Data/Rebuild All Data (Forcefully) (M)enu (M)aster (I)tems (C)reate (I)tems. Enter Item Name, Item Group, Unit of Measurement, Opening Stock, and other details. Click Save.</li>
- <li>To edit or delete an item master in Busywin, go to Master Creation/Alteration/Delete/Display/Print/Import/Export/Rebuild Indexes/Rebuild Data/Rebuild All Data/Rebuild All Data (Forcefully) (M)enu (M)aster (I)tems (A)lteration/(D)eletion. Select Item Name and press F2 for Edit or F3 for Delete.</li>
- <li>To print an item master in Busywin, go to Display > Inventory Books/Ledgers/Trial Balance/Balance Sheet/P&L A/c/Cash Flow/Fund Flow/Ratio Analysis/Bank Reconciliation Statement/Multi Columnar Reports/Multi Columnar Reports with Graphs/Multi Columnar Reports with Graphs & Narrations/Multi Columnar Reports with Narrations/Multi Columnar Reports with Narrations & Graphs/Multi Columnar Reports with Narrations & Graphs & Narrations/Multi Columnar Reports with Narrations & Graphs & Narrations & Graphs/Multi Columnar Reports with Narrations & Graphs & Narrations & Graphs/Multi Columnar Reports with Narrations & Graphs & Narrations & Graphs & Narrations & Graphs & Narrations & Graph & Narrative Reports. Select Item Name and press F5 for Print.</li>
-</ul>
-<p>You will see a screen like this:</p>
-<img src="https://i.imgur.com/X7JZ0Xf.png" alt="Busywin item master print screen">
-<p>This screen shows the item master details and stock summary of the selected item.</p> <h2>Benefits of using Busywin 14 rel 6.1</h2>
-<p>By using Busywin 14 rel 6.1, you can enjoy many benefits for your business accounting and management. Here are some of them:</p>
- <ul>
- <li>Centralized database: Busywin allows you to centralize your key business processes such as invoicing, customer relationship management, payroll, and inventory management. You can access and update your data from any location and device with an internet connection. You can also backup your data on the cloud or FTP server for extra security.</li>
- <li>Improved speed and performance: Busywin uses a client-server architecture that improves the speed and performance of data processing. The database engine and the data files reside on a single computer only, which reduces the network traffic and increases the application speed.</li>
- <li>GST compliance: Busywin is a GST-ready software that helps you in GST billing, filing, and reconciliation. You can generate GST invoices, e-way bills, GSTR reports, and GST ledgers with Busywin. You can also detect and correct errors in your GST data with Busywin's powerful tools.</li>
- <li>Multi-currency and multi-branch support: Busywin supports multiple currencies and multiple branches for your business. You can manage your export/import transactions with different currencies and exchange rates. You can also manage your multiple branches with separate accounts and reports.</li>
- <li>Customizable reports and documents: Busywin allows you to customize your reports and documents according to your preferences. You can use user-configurable invoicing, vouchers, letters, and reports to create professional and branded documents. You can also use multi-columnar reports, graphs, narrations, and collaboration tools to enhance your data analysis and presentation.</li>
- <li>Customer support and training: Busywin provides customer support and training to help you use the software effectively. You can contact the support team by email, phone, or online chat. You can also access the FAQs, forum, knowledge base, videos, webinars, and documentation for self-help.</li>
- </ul>
-<p>These are some of the benefits of using Busywin 14 rel 6.1 for your business accounting and management. You can try it for free for 30 days by downloading it from the official website.</p>
- <h2>Conclusion and FAQs</h2>
-<p>In this article, we have shown you what is Busywin and why you need it for your business accounting and management. We have also shown you how to download and install Busywin 14 rel 6.1, how to crack it to use it for free, how to use it after cracking it, and what are the benefits of using it.</p>
-<p>We hope you have found this article useful and informative. If you have any questions or feedback, please feel free to contact us or leave a comment below.</p>
-<p>Here are some FAQs that you might have:</p>
- <h3>Q: Is cracking Busywin illegal?</h3>
-<p>A: Yes, cracking Busywin is illegal and unethical. It violates the intellectual property rights of the software developers and may expose your PC to viruses or malware. It may also cause errors or glitches in the software performance or functionality. We do not recommend or endorse cracking software in any way. We are only providing this information for educational purposes only.</p>
- <h3>Q: How can I buy a license key for Busywin?</h3>
-<p>A: You can buy a license key for Busywin from the official website at <a href="http://busywin.com/">http://busywin.com/</a>. You can choose from different editions and versions of Busywin according to your needs and budget.</p>
- <h3>Q: How can I update my Busywin software?</h3>
-<p>A: You can update your Busywin software by downloading the latest version from the official website at <a href="http://busywin.com/">http://busywin.com/</a>. You can also check for updates from within the software by going to Help > Check for Updates.</p>
- <h3>Q: How can I connect multiple branches using Busywin?</h3>
-<p>A: You can connect multiple branches using Busywin by using the multi-branch feature of Busywin Enterprise Edition or Corporate Edition. You can create separate accounts and reports for each branch and synchronize them with the head office using an internet connection.</p>
- <h3>Q: How can I use Busywin on my mobile device?</h3>
-<p>A: You can use Busywin on your mobile device by downloading the Busy Mobile App from Google Play Store. The app allows you to track your accounting data on the go. You can also use Busy on Cloud service to access your Busy software from any internet connected device.</p>
- </p> 0a6ba089eb<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/raedeXanto/academic-chatgpt-beta/CorelDRAW Graphics Suite 2019 Keygen and Crack (WIN MAC) The Best Way to Edit Photos Illustrations and Layouts.md b/spaces/raedeXanto/academic-chatgpt-beta/CorelDRAW Graphics Suite 2019 Keygen and Crack (WIN MAC) The Best Way to Edit Photos Illustrations and Layouts.md
deleted file mode 100644
index 16d394a2f8ea74e8d8ae4d5b0a196e40fe349185..0000000000000000000000000000000000000000
--- a/spaces/raedeXanto/academic-chatgpt-beta/CorelDRAW Graphics Suite 2019 Keygen and Crack (WIN MAC) The Best Way to Edit Photos Illustrations and Layouts.md	
+++ /dev/null
@@ -1,139 +0,0 @@
-
-<h1>CorelDRAW Graphics Suite 2019 Keygen and Crack (WIN MAC)</h1>
-<p>If you are looking for a powerful and complete graphic design software that can help you create stunning projects with ease, then you should consider CorelDRAW Graphics Suite 2019. This software is an impressive application that has been equipped with loads of tools and options to help you create some astonishing projects. Whether you want to create logos, ads, websites, illustrations, vector images, or any other graphic design project, CorelDRAW Graphics Suite 2019 can handle it all.</p>
-<h2>CorelDRAW Graphics Suite 2019 Keygen and Crack (WIN MAC)</h2><br /><p><b><b>Download File</b> &#9733; <a href="https://tinourl.com/2uL30Y">https://tinourl.com/2uL30Y</a></b></p><br /><br />
-<p>In this article, we will show you what are the features of CorelDRAW Graphics Suite 2019, how to download and install it for free, and how to use it for graphic design. By the end of this article, you will have a clear idea of why CorelDRAW Graphics Suite 2019 is one of the best graphic design software in the market.</p>
- <h2>Features of CorelDRAW Graphics Suite 2019</h2>
-<p>CorelDRAW Graphics Suite 2019 is a comprehensive graphic design software that offers a collection of seven powerful applications to meet all types of creativity. These applications include:</p>
-<ul>
-<li>CorelDRAW: A vector graphics editor that lets you create logos, icons, illustrations, page layouts, web graphics, and more.</li>
-<li>Corel PHOTO-PAINT: A raster graphics editor that lets you perform pixel editing on bitmap images, apply effects, filters, adjustments, and more.</li>
-<li>Corel Font Manager: A font management tool that lets you browse, organize, preview, and install fonts on your system.</li>
-<li>Corel PowerTRACE: A bitmap-to-vector tracing tool that lets you convert raster images into editable vector graphics.</li>
-<li>Corel CAPTURE: A screen capture tool that lets you capture images from your screen with one click.</li>
-<li>Corel CONNECT: A content browser that lets you search and manage photos, fonts, clip art, and other assets from your computer or online sources.</li>
-<li>CorelDRAW.app: A web-based application that lets you access your CorelDRAW files from any device and collaborate with clients and colleagues online.</li>
-</ul>
-<p>Some of the features that make CorelDRAW Graphics Suite 2019 stand out from other graphic design software are:</p>
- <h3>Objects Docker</h3>
-<p>This feature allows you to manage objects more easily by showing all the objects in your document in a hierarchical list. You can select, hide, lock, rename, group, ungroup, align, order, and transform objects with ease. You can also use filters to find objects by type, name, color, or other attributes.</p>
-<p>How to activate CorelDRAW Graphics Suite 2019 for free on Windows and Mac<br />
-CorelDRAW Graphics Suite 2019 full version download with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 serial number and activation code generator<br />
-CorelDRAW Graphics Suite 2019 patch and license key for Windows and Mac<br />
-CorelDRAW Graphics Suite 2019 cracked software free download for PC and Mac<br />
-CorelDRAW Graphics Suite 2019 keygen and crack download link<br />
-CorelDRAW Graphics Suite 2019 torrent with keygen and crack included<br />
-CorelDRAW Graphics Suite 2019 registration key and crack file<br />
-CorelDRAW Graphics Suite 2019 product key and crack folder<br />
-CorelDRAW Graphics Suite 2019 installation guide with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 offline installer with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 latest version with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 update with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 review with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 features with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 system requirements with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 comparison with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 alternatives with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 tips and tricks with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 tutorials with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 support with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 forum with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 blog with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 coupon code with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 discount offer with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 free trial with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 refund policy with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 warranty information with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 testimonials with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 FAQs with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 problems and solutions with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 errors and fixes with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 bugs and patches with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 compatibility issues with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 performance optimization with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 security enhancement with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 privacy protection with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 backup and restore with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 uninstallation process with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 reinstallation steps with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 upgrade instructions with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 downgrade options with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 customization settings with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 keyboard shortcuts with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 plugins and extensions with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 templates and presets with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 fonts and icons with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 brushes and tools with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 filters and effects with keygen and crack<br />
-CorelDRAW Graphics Suite 2019 projects and samples with keygen and crack</p>
- <h3>Pixel Overflow</h3>
-<p>This feature allows you to control how objects are displayed when they extend beyond the edge of a page or container. You can choose to show or hide the overflowed pixels or crop them automatically. This can help you create cleaner designs and avoid unwanted artifacts.</p>
- <h3>Templates Workspace</h3>
-<p>This feature allows you to access a variety of templates for different types of projects from within the application. You can browse templates by category, such as brochures, flyers, posters, business cards, logos, etc. You can also create your own templates and save them for future use.</p>
- <h3>File Compatibility</h3>
-<p>This feature allows you to work with files from various formats and applications without losing quality or functionality. You can import and export files in formats such as AI, PSD, PDF, JPG, PNG, SVG, EPS, TIFF, etc. You can also open files from Adobe Illustrator, Photoshop, InDesign,</p><table><tr><td>InDesign,</td><td>and more.</td></tr></table><p>You can also save files in formats such as CDR (CorelDRAW), CPT (Corel PHOTO-PAINT), CGM (Computer Graphics Metafile), etc.</p>
- <h3>PDF/X Standards</h3>
-<p>This feature allows you to create PDF files that comply with various industry standards for printing and publishing. You can choose from different PDF/X presets or customize your own settings to ensure optimal output quality and compatibility.</p>
- <h3>Comfortable Interface</h3>
-<p>This feature allows you to customize your workspace according to your preferences and needs. You can choose from different themes (light or dark), toolbars (standard or simplified), icons (large or small), docking windows (dockable or floating), etc. You can also create your own shortcuts, commands,</p><table><tr><td>commands,</td><td>and menus.</td></tr></table><p>You can also switch between different workspaces for different tasks or workflows.</p>
- <h3>Import & Export with Ease</h3>
-<p>This feature allows you to import and export files from various sources with ease. You can drag and drop files from your computer or online sources into your document. You can also use the Publish to PDF option to export your document as a PDF file with one click. You can also use the Share option</p><table><tr><td>the Share option</td><td>to send your document via email or upload it to cloud storage services such as Dropbox or Google Drive.</td></tr></table>
- <h2>How to Download and Install CorelDRAW Graphics Suite 2019 for Free</h2>
-<p>If you want to try CorelDRAW Graphics Suite 2019 for free without using any crack or keygen, you can download it here. This is a pre-activated version that does not require any crack, serial,</p><table><tr><td>serial,</td><td>or patch.</td></tr></table><p>To download and install CorelDRAW Graphics Suite 2019 for free, follow these steps:</p>
- <h3>Download CorelDRAW 2019 full crack for windows 64 bit</h3>
-<p>Click on the link above to download the file. The file size is about 680 MB. It may take some time depending on your internet speed. Once the download is complete, open the file.</p>
- <h3>Turn off internet and antivirus connections</h3>
-<p>To avoid any interference or errors during installation, turn off your internet connection and antivirus software temporarily. You can turn them back on after installation is complete.</p>
- <h3>Extract files with the latest Winrar</h3>
-<p>To extract the files from the compressed file, you need a software such as Winrar. You can download it here. Once you have Winrar installed, right-click on the file and select Extract Here. This will create a folder named Coreldraw_Graphics_Suite_2019_v21.x64_Multilingual_Preactivated.</p>
- <h3>Open and Edit the Windows hosts file</h3>
-<p>To prevent CorelDRAW from connecting to its servers and getting blacklisted, you need to edit the Windows hosts file. To do this, open Notepad as administrator by right-clicking on it and selecting Run as administrator. <h3>Pre-activated! no need for crack, serial or patch</h3>
-<p>Now you are ready to install CorelDRAW Graphics Suite 2019. Go to the folder Coreldraw_Graphics_Suite_2019_v21.x64_Multilingual_Preactivated and run the file Setup.exe. Follow the instructions on the screen to complete the installation. You do not need to enter any crack, serial or patch as this is a pre-activated version.</p>
-<p>Congratulations! You have successfully installed CorelDRAW Graphics Suite 2019 for free.</p>
- <h2>How to Use CorelDRAW Graphics Suite 2019 for Graphic Design</h2>
-<p>Now that you have CorelDRAW Graphics Suite 2019 installed on your computer, you can start using it for graphic design. Here are some tips on how to use CorelDRAW Graphics Suite 2019 for graphic design:</p>
- <h3>Create impressive logos, ads and websites</h3>
-<p>With CorelDRAW Graphics Suite 2019, you can create logos, ads and websites that stand out from the crowd. You can use the vector graphics editor CorelDRAW to create logos, icons, illustrations, page layouts, web graphics, and more. You can use the raster graphics editor Corel PHOTO-PAINT to perform pixel editing on bitmap images, apply effects, filters, adjustments, and more. You can also use the templates workspace to access a variety of templates for different types of projects.</p>
- <h3>Collaborate with clients and colleagues using CorelDRAW.app</h3>
-<p>With CorelDRAW Graphics Suite 2019, you can collaborate with clients and colleagues online using CorelDRAW.app. This is a web-based application that lets you access your CorelDRAW files from any device and share them with others. You can also make edits and comments on your files in real-time.</p>
- <h3>Explore your creativity and unleash the artist in you</h3>
-<p>With CorelDRAW Graphics Suite 2019, you can explore your creativity and unleash the artist in you in a very intuitive environment. You can use cutting-edge font technologies and enhanced type tools to create stunning typography. You can also use analogies and metaphors in your designs to convey your message more effectively.</p>
- <h2>Conclusion</h2>
-<p>CorelDRAW Graphics Suite 2019 is a powerful and complete graphic design software that can help you create stunning projects with ease. It has a collection of seven powerful applications that offer a variety of tools and options to help you create logos, ads, websites, illustrations, vector images, and more. It also has features such as objects docker, pixel overflow, templates workspace, file compatibility, PDF/X standards, comfortable interface, import & export with ease, and more. It also allows you to collaborate with clients and colleagues online using CorelDRAW.app.</p>
-<p>If you want to try CorelDRAW Graphics Suite 2019 for free without using any crack or keygen, you can download it here. This is a pre-activated version that does not require any crack, serial,</p><table><tr><td>serial,</td><td>or patch.</td></tr></table><p>We hope this article has helped you learn more about CorelDRAW Graphics Suite 2019 and how to use it for graphic design. If you have any questions or feedback, please feel free to leave a comment below.</p>
- <h2>FAQs</h2>
-<h3>What are the system requirements for CorelDRAW Graphics Suite 2019?</h3>
-<p>The system requirements for CorelDRAW Graphics Suite 2019 are as follows:</p>
-<ul>
-<li>Windows 10*, 8.1 or Windows 7 (64-bit only), with the latest updates and service packs</li>
-<li>Intel Core i3/5/7 or AMD Athlon 64 processor</li>
-<li>2 GB RAM (4 GB recommended)</li>
-<li>2.5 GB hard disk space</li>
-<li>Multi-touch screen, mouse or tablet</li>
-<li>1280 x 720 screen resolution at 100% (96 dpi)</li>
-<li>Microsoft Internet Explorer 11 or higher</li>
-<li>Microsoft .NET Framework 4.7.2</li>
-<li>DVD drive optional (for box installation)</li>
-<li>*CorelDRAW Graphics Suite 2019 supports Windows 10 version 1803 (April 2018 update) and later versions being released during the lifecycle of CorelDRAW Graphics Suite 2019.</li>
-</ul>
- <h3>How can I update my CorelDRAW Graphics Suite 2019?</h3>
-<p>To update your CorelDRAW Graphics Suite 2019, you can use the Update option in the Help menu of the application. This will check for any available updates and install them automatically. You can also download the updates manually from the official website.</p>
- <h3>What are the differences between CorelDRAW Graphics Suite 2019 and CorelDRAW 2020?</h3>
-<p>The main differences between CorelDRAW Graphics Suite 2019 and CorelDRAW 2020 are:</p>
-<ul>
-<li>CorelDRAW 2020 has a new feature called PowerTRACE AI that uses artificial intelligence to improve bitmap-to-vector tracing results.</li>
-<li>CorelDRAW 2020 has a new feature called Variable Font Support that lets you adjust font properties such as weight, width, slant, etc.</li>
-<li>CorelDRAW 2020 has a new feature called Non-Destructive Effects that lets you apply effects such as shadows, glows, bevels, etc. without altering the original object.</li>
-<li>CorelDRAW 2020 has a new feature called Collaboration Workflow that lets you share your designs with others via cloud storage services such as Dropbox or Google Drive.</li>
-<li>CorelDRAW 2020 has a new feature called Find & Replace Docker that lets you find and replace text or objects across multiple documents.</li>
-<li>CorelDRAW 2020 has improved performance and stability compared to CorelDRAW Graphics Suite 2019.</li>
-</ul>
- <h3>How can I get support for CorelDRAW Graphics Suite 2019?</h3>
-<p>If you need support for CorelDRAW Graphics Suite 2019, you can visit the official website and access various resources such as tutorials, <h3>How can I get support for CorelDRAW Graphics Suite 2019?</h3>
-<p>If you need support for CorelDRAW Graphics Suite 2019, you can visit the official website and access various resources such as tutorials, videos,</p><table><tr><td>videos,</td><td>user guides, forums, blogs, etc.</td></tr></table><p>You can also contact the customer support team via phone, email, or chat.</p>
- <h3>Is CorelDRAW Graphics Suite 2019 compatible with Mac?</h3>
-<p>Yes, CorelDRAW Graphics Suite 2019 is compatible with Mac. You can download the Mac version of CorelDRAW Graphics Suite 2019 here. The Mac version has the same features and functions as the Windows version, except for Corel CONNECT and Corel CAPTURE. Instead, you can use the built-in Finder and Preview applications on Mac to browse and capture images.</p>
- </p> 0a6ba089eb<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/rasmodev/sepsis_prediction/Dockerfile b/spaces/rasmodev/sepsis_prediction/Dockerfile
deleted file mode 100644
index 238f6b414fcc176e64ac25435677fc06edd5c053..0000000000000000000000000000000000000000
--- a/spaces/rasmodev/sepsis_prediction/Dockerfile
+++ /dev/null
@@ -1,23 +0,0 @@
-# Use the official Python image as a parent image
-FROM python:3.11.3-slim
-
-# Set the working directory within the container
-WORKDIR /app
-
-# Copy the requirements.txt file into the container
-COPY ./requirements.txt /app/requirements.txt
-
-# Install the Python dependencies
-RUN pip install -r /app/requirements.txt
-
-# Copy your FastAPI application code into the container
-COPY ./app.py /app/app.py
-
-# Copy the model and key components into the container
-COPY ./model_and_key_components.pkl /app/model_and_key_components.pkl
-
-# Expose port 8000 for the FastAPI application
-EXPOSE 7860
-
-# Define the command to run your FastAPI application
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
diff --git a/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Dil Ne Jise Apna Kahaa Hd Movie UPD Download 1080p.md b/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Dil Ne Jise Apna Kahaa Hd Movie UPD Download 1080p.md
deleted file mode 100644
index 95a6c3203d78d9a682b5fb0600805cbfb308c072..0000000000000000000000000000000000000000
--- a/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Dil Ne Jise Apna Kahaa Hd Movie UPD Download 1080p.md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>Dil Ne Jise Apna Kahaa hd movie download 1080p</h2><br /><p><b><b>DOWNLOAD</b> &#10004;&#10004;&#10004; <a href="https://urlgoal.com/2uCM87">https://urlgoal.com/2uCM87</a></b></p><br /><br />
-
-Download Full Movie" HD Dil Ne ... Apartment 3 hindi torrent download Soch Lo 2 full movie . telugu movie download .... Dil. Ne Jise Apna Kahaa 1080p full ... 1fdad05405<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Fidic Silver Book Epc Turnkey Contract Free ((FREE)) Download.md b/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Fidic Silver Book Epc Turnkey Contract Free ((FREE)) Download.md
deleted file mode 100644
index b089e41d1a71cd0ffe3b2bb5740b33c09ab6eb31..0000000000000000000000000000000000000000
--- a/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Fidic Silver Book Epc Turnkey Contract Free ((FREE)) Download.md	
+++ /dev/null
@@ -1,108 +0,0 @@
-<br />
-<h1>FIDIC Silver Book EPC Turnkey Contract Free Download: What You Need to Know</h1>
-
-<p>If you are involved in engineering, procurement and construction (EPC) turnkey projects, you may be interested in the FIDIC Silver Book EPC Turnkey Contract Free Download. This is a document that contains the conditions of contract for EPC turnkey projects, published by the International Federation of Consulting Engineers (FIDIC).</p>
-
-<p>EPC turnkey projects are projects where the contractor is responsible for delivering a complete facility to the employer, ready to operate at the turn of a key. The contractor designs, builds and tests the facility according to the employer's requirements and specifications. The contractor also assumes most of the risks involved in the project, such as design errors, delays, cost overruns, quality issues and performance failures.</p>
-<h2>fidic silver book epc turnkey contract free download</h2><br /><p><b><b>Download Zip</b> &#11088; <a href="https://urlgoal.com/2uCKo2">https://urlgoal.com/2uCKo2</a></b></p><br /><br />
-
-<p>The FIDIC Silver Book EPC Turnkey Contract is a standard form of contract that can be used for EPC turnkey projects. It is based on the principle of risk sharing between the parties, where the contractor takes most of the risks and the employer pays a fixed price for the project. The FIDIC Silver Book EPC Turnkey Contract also provides guidance for the preparation of particular conditions and annexes, such as forms of securities, letter of tender, contract agreement and dispute adjudication/avoidance agreement.</p>
-
-<h2>How to Get the FIDIC Silver Book EPC Turnkey Contract Free Download</h2>
-
-<p>If you want to get the FIDIC Silver Book EPC Turnkey Contract Free Download, you can visit the FIDIC website at https://fidic.org/books/epcturnkey-contract-2nd-ed-2017-silver-book. There you can find different versions of the FIDIC Silver Book EPC Turnkey Contract, such as:</p>
-
-<ul>
-<li>The Second Edition (2017), which is the latest version of the FIDIC Silver Book EPC Turnkey Contract. It updates and improves the First Edition (1999), which has been in widespread use for nearly two decades. The Second Edition provides greater detail and clarity on the requirements for notices and other communications, addresses employers' and contractors' claims equally and separately from disputes, introduces mechanisms for dispute avoidance and includes detailed provisions for quality management and verification of contractor's contractual compliance.</li>
-<li>The Reprint (2022), which contains amendments to the Second Edition (2017). The amendments are minor corrections and clarifications that do not affect the substance of the contract. The amendments are also available as a separate document that can be downloaded for free from https://fidic.org/books/epcturnkey-contract-2nd-ed-2017-silver-book-book-reprinted-2022-amendments.</li>
-<li>The First Edition (1999), which is still available for reference purposes. However, FIDIC recommends that users adopt the Second Edition (2017) or its Reprint (2022) for their EPC turnkey projects.</li>
-</ul>
-
-<p>To get any of these versions of the FIDIC Silver Book EPC Turnkey Contract Free Download, you need to select your preferred language (English or French) and format (hardcopy or electronic) and add it to your cart. You will then need to register or log in to your FIDIC account and proceed to checkout. You will not be charged any fee for downloading the electronic version of the FIDIC Silver Book EPC Turnkey Contract.</p>
-
-<h2>How to Use the FIDIC Silver Book EPC Turnkey Contract</h2>
-
-<p>To use the FIDIC Silver Book EPC Turnkey Contract for your EPC turnkey projects, you need to follow these steps:</p>
-
-<ol>
-<li>Review the general conditions of contract and understand their implications for your project. The general conditions of contract contain 21 clauses that cover various aspects of the project, such as definitions, obligations, design, payment, termination, claims and disputes.</li>
-<li>Prepare your particular conditions of contract and annexes according to your specific needs and circumstances. The particular conditions of contract modify or supplement the general conditions of contract to suit your project. The annexes provide additional information and documents that are relevant to your project, such as forms of securities, letter of tender, contract agreement and dispute adjudication/avoidance agreement.</li>
-<li>Negotiate and agree on your contract with your counterpart. You should ensure that your contract reflects your mutual understanding and expectations regarding your project. You should also ensure that your contract complies with any applicable laws and regulations in your jurisdiction.</li>
-<li>Implement and manage your contract according to its terms and conditions. You should perform your obligations diligently and professionally. You should also communicate effectively and cooperate with your counterpart. You should also resolve any issues or disputes that may arise during your project amicably or through an agreed dispute resolution mechanism.</li>
-</ol>
-
-<p>You can find more details and examples on how to use the FIDIC Silver Book EPC Turnkey Contract in the FIDIC Model Documentation and the FIDIC Tutorials available on the FIDIC website.</p>
-
-<h2>Conclusion</h2>
-
-<p>The FIDIC Silver Book EPC Turnkey Contract Free Download is a valuable resource for anyone involved in EPC turnkey projects. It is a standard form of contract that can be used for EPC turnkey projects. It is based on the principle of risk sharing between the parties, where the contractor takes most of the risks and the employer pays a fixed price for the project.</p>
-
-<p>You can get the FIDIC Silver Book EPC Turnkey Contract Free Download from
-the FIDIC website at https://fidic.org/books/epcturnkey-contract-2nd-ed-2017-silver-book.
-You can choose from different versions of
-the FIDIC Silver Book EPC Turnkey Contract,
-such as
-the Second Edition (2017),
-the Reprint (2022),
-or
-the First Edition (1999).</p>
-
-<p>You can use
-the FIDIC Silver Book EPC Turnkey Contract
-for your EPC turnkey projects
-by reviewing
-the general conditions of contract,
-preparing
-the particular conditions of contract
-and annexes,
-negotiating
-and agreeing on
-your contract
-with your counterpart,
-and implementing
-and managing
-your contract
-according to its terms
-and conditions.</p>
-<p></p>
-
-<p>We hope this article has helped you learn more about
-the FIDIC Silver Book EPC Turnkey Contract Free Download
-and how to use it
-for your EPC turnkey projects.</p>
-<p>The FIDIC Silver Book EPC Turnkey Contract Free Download is a valuable resource for anyone involved in EPC turnkey projects. It is a standard form of contract that can be used for EPC turnkey projects. It is based on the principle of risk sharing between the parties, where the contractor takes most of the risks and the employer pays a fixed price for the project.</p>
-
-<p>You can get the FIDIC Silver Book EPC Turnkey Contract Free Download from
-the FIDIC website at https://fidic.org/books/epcturnkey-contract-2nd-ed-2017-silver-book.
-You can choose from different versions of
-the FIDIC Silver Book EPC Turnkey Contract,
-such as
-the Second Edition (2017),
-the Reprint (2022),
-or
-the First Edition (1999).</p>
-
-<p>You can use
-the FIDIC Silver Book EPC Turnkey Contract
-for your EPC turnkey projects
-by reviewing
-the general conditions of contract,
-preparing
-the particular conditions of contract
-and annexes,
-negotiating
-and agreeing on
-your contract
-with your counterpart,
-and implementing
-and managing
-your contract
-according to its terms
-and conditions.</p>
-
-<p>We hope this article has helped you learn more about
-the FIDIC Silver Book EPC Turnkey Contract Free Download
-and how to use it
-for your EPC turnkey projects.</p> 3cee63e6c2<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/reha/Stick_Tech/modules.py b/spaces/reha/Stick_Tech/modules.py
deleted file mode 100644
index 52ee14e41a5b6d67d875d1b694aecd2a51244897..0000000000000000000000000000000000000000
--- a/spaces/reha/Stick_Tech/modules.py
+++ /dev/null
@@ -1,342 +0,0 @@
-import copy
-import math
-import numpy as np
-import scipy
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm
-
-import commons
-from commons import init_weights, get_padding
-
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
-  def __init__(self, channels, eps=1e-5):
-    super().__init__()
-    self.channels = channels
-    self.eps = eps
-
-    self.gamma = nn.Parameter(torch.ones(channels))
-    self.beta = nn.Parameter(torch.zeros(channels))
-
-  def forward(self, x):
-    x = x.transpose(1, -1)
-    x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
-    return x.transpose(1, -1)
-
- 
-class ConvReluNorm(nn.Module):
-  def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout):
-    super().__init__()
-    self.in_channels = in_channels
-    self.hidden_channels = hidden_channels
-    self.out_channels = out_channels
-    self.kernel_size = kernel_size
-    self.n_layers = n_layers
-    self.p_dropout = p_dropout
-    assert n_layers > 1, "Number of layers should be larger than 0."
-
-    self.conv_layers = nn.ModuleList()
-    self.norm_layers = nn.ModuleList()
-    self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size//2))
-    self.norm_layers.append(LayerNorm(hidden_channels))
-    self.relu_drop = nn.Sequential(
-        nn.ReLU(),
-        nn.Dropout(p_dropout))
-    for _ in range(n_layers-1):
-      self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size//2))
-      self.norm_layers.append(LayerNorm(hidden_channels))
-    self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-    self.proj.weight.data.zero_()
-    self.proj.bias.data.zero_()
-
-  def forward(self, x, x_mask):
-    x_org = x
-    for i in range(self.n_layers):
-      x = self.conv_layers[i](x * x_mask)
-      x = self.norm_layers[i](x)
-      x = self.relu_drop(x)
-    x = x_org + self.proj(x)
-    return x * x_mask
-
-
-class DDSConv(nn.Module):
-  """
-  Dialted and Depth-Separable Convolution
-  """
-  def __init__(self, channels, kernel_size, n_layers, p_dropout=0.):
-    super().__init__()
-    self.channels = channels
-    self.kernel_size = kernel_size
-    self.n_layers = n_layers
-    self.p_dropout = p_dropout
-
-    self.drop = nn.Dropout(p_dropout)
-    self.convs_sep = nn.ModuleList()
-    self.convs_1x1 = nn.ModuleList()
-    self.norms_1 = nn.ModuleList()
-    self.norms_2 = nn.ModuleList()
-    for i in range(n_layers):
-      dilation = kernel_size ** i
-      padding = (kernel_size * dilation - dilation) // 2
-      self.convs_sep.append(nn.Conv1d(channels, channels, kernel_size, 
-          groups=channels, dilation=dilation, padding=padding
-      ))
-      self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
-      self.norms_1.append(LayerNorm(channels))
-      self.norms_2.append(LayerNorm(channels))
-
-  def forward(self, x, x_mask, g=None):
-    if g is not None:
-      x = x + g
-    for i in range(self.n_layers):
-      y = self.convs_sep[i](x * x_mask)
-      y = self.norms_1[i](y)
-      y = F.gelu(y)
-      y = self.convs_1x1[i](y)
-      y = self.norms_2[i](y)
-      y = F.gelu(y)
-      y = self.drop(y)
-      x = x + y
-    return x * x_mask
-
-
-class WN(torch.nn.Module):
-  def __init__(self, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=0, p_dropout=0):
-    super(WN, self).__init__()
-    assert(kernel_size % 2 == 1)
-    self.hidden_channels =hidden_channels
-    self.kernel_size = kernel_size,
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.gin_channels = gin_channels
-    self.p_dropout = p_dropout
-
-    self.in_layers = torch.nn.ModuleList()
-    self.res_skip_layers = torch.nn.ModuleList()
-    self.drop = nn.Dropout(p_dropout)
-
-    if gin_channels != 0:
-      cond_layer = torch.nn.Conv1d(gin_channels, 2*hidden_channels*n_layers, 1)
-      self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight')
-
-    for i in range(n_layers):
-      dilation = dilation_rate ** i
-      padding = int((kernel_size * dilation - dilation) / 2)
-      in_layer = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, kernel_size,
-                                 dilation=dilation, padding=padding)
-      in_layer = torch.nn.utils.weight_norm(in_layer, name='weight')
-      self.in_layers.append(in_layer)
-
-      # last one is not necessary
-      if i < n_layers - 1:
-        res_skip_channels = 2 * hidden_channels
-      else:
-        res_skip_channels = hidden_channels
-
-      res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
-      res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight')
-      self.res_skip_layers.append(res_skip_layer)
-
-  def forward(self, x, x_mask, g=None, **kwargs):
-    output = torch.zeros_like(x)
-    n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
-    if g is not None:
-      g = self.cond_layer(g)
-
-    for i in range(self.n_layers):
-      x_in = self.in_layers[i](x)
-      if g is not None:
-        cond_offset = i * 2 * self.hidden_channels
-        g_l = g[:,cond_offset:cond_offset+2*self.hidden_channels,:]
-      else:
-        g_l = torch.zeros_like(x_in)
-
-      acts = commons.fused_add_tanh_sigmoid_multiply(
-          x_in,
-          g_l,
-          n_channels_tensor)
-      acts = self.drop(acts)
-
-      res_skip_acts = self.res_skip_layers[i](acts)
-      if i < self.n_layers - 1:
-        res_acts = res_skip_acts[:,:self.hidden_channels,:]
-        x = (x + res_acts) * x_mask
-        output = output + res_skip_acts[:,self.hidden_channels:,:]
-      else:
-        output = output + res_skip_acts
-    return output * x_mask
-
-  def remove_weight_norm(self):
-    if self.gin_channels != 0:
-      torch.nn.utils.remove_weight_norm(self.cond_layer)
-    for l in self.in_layers:
-      torch.nn.utils.remove_weight_norm(l)
-    for l in self.res_skip_layers:
-     torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
-        super(ResBlock1, self).__init__()
-        self.convs1 = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
-                               padding=get_padding(kernel_size, dilation[0]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
-                               padding=get_padding(kernel_size, dilation[1]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
-                               padding=get_padding(kernel_size, dilation[2])))
-        ])
-        self.convs1.apply(init_weights)
-
-        self.convs2 = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1)))
-        ])
-        self.convs2.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c1, c2 in zip(self.convs1, self.convs2):
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c1(xt)
-            xt = F.leaky_relu(xt, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c2(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs1:
-            remove_weight_norm(l)
-        for l in self.convs2:
-            remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
-        super(ResBlock2, self).__init__()
-        self.convs = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
-                               padding=get_padding(kernel_size, dilation[0]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
-                               padding=get_padding(kernel_size, dilation[1])))
-        ])
-        self.convs.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c in self.convs:
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs:
-            remove_weight_norm(l)
-
-
-class Log(nn.Module):
-  def forward(self, x, x_mask, reverse=False, **kwargs):
-    if not reverse:
-      y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
-      logdet = torch.sum(-y, [1, 2])
-      return y, logdet
-    else:
-      x = torch.exp(x) * x_mask
-      return x
-    
-
-class Flip(nn.Module):
-  def forward(self, x, *args, reverse=False, **kwargs):
-    x = torch.flip(x, [1])
-    if not reverse:
-      logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
-      return x, logdet
-    else:
-      return x
-
-
-class ElementwiseAffine(nn.Module):
-  def __init__(self, channels):
-    super().__init__()
-    self.channels = channels
-    self.m = nn.Parameter(torch.zeros(channels,1))
-    self.logs = nn.Parameter(torch.zeros(channels,1))
-
-  def forward(self, x, x_mask, reverse=False, **kwargs):
-    if not reverse:
-      y = self.m + torch.exp(self.logs) * x
-      y = y * x_mask
-      logdet = torch.sum(self.logs * x_mask, [1,2])
-      return y, logdet
-    else:
-      x = (x - self.m) * torch.exp(-self.logs) * x_mask
-      return x
-
-
-class ResidualCouplingLayer(nn.Module):
-  def __init__(self,
-      channels,
-      hidden_channels,
-      kernel_size,
-      dilation_rate,
-      n_layers,
-      p_dropout=0,
-      gin_channels=0,
-      mean_only=False):
-    assert channels % 2 == 0, "channels should be divisible by 2"
-    super().__init__()
-    self.channels = channels
-    self.hidden_channels = hidden_channels
-    self.kernel_size = kernel_size
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.half_channels = channels // 2
-    self.mean_only = mean_only
-
-    self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
-    self.enc = WN(hidden_channels, kernel_size, dilation_rate, n_layers, p_dropout=p_dropout, gin_channels=gin_channels)
-    self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
-    self.post.weight.data.zero_()
-    self.post.bias.data.zero_()
-
-  def forward(self, x, x_mask, g=None, reverse=False):
-    x0, x1 = torch.split(x, [self.half_channels]*2, 1)
-    h = self.pre(x0) * x_mask
-    h = self.enc(h, x_mask, g=g)
-    stats = self.post(h) * x_mask
-    if not self.mean_only:
-      m, logs = torch.split(stats, [self.half_channels]*2, 1)
-    else:
-      m = stats
-      logs = torch.zeros_like(m)
-
-    if not reverse:
-      x1 = m + x1 * torch.exp(logs) * x_mask
-      x = torch.cat([x0, x1], 1)
-      logdet = torch.sum(logs, [1,2])
-      return x, logdet
-    else:
-      x1 = (x1 - m) * torch.exp(-logs) * x_mask
-      x = torch.cat([x0, x1], 1)
-      return x
diff --git a/spaces/renumics/commonlit-student-summaries/README.md b/spaces/renumics/commonlit-student-summaries/README.md
deleted file mode 100644
index c81e3f54d15fafea7795803f2dd2634735b2b8f2..0000000000000000000000000000000000000000
--- a/spaces/renumics/commonlit-student-summaries/README.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Visualize Commonlit Summary Result Predictions in Spotlight
-emoji: 🕵️‍♀️
-colorFrom: gray
-colorTo: blue
-sdk: docker
-pinned: false
-license: gpl-3.0
-app_file: run.py
-tags:
-- renumics
-- spotlight
-- EDA
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/rewoo/ReWOO-Demo/alpaca/utils/prompter.py b/spaces/rewoo/ReWOO-Demo/alpaca/utils/prompter.py
deleted file mode 100644
index d35e82296f9dda313c340fee134b7c11b28c13c3..0000000000000000000000000000000000000000
--- a/spaces/rewoo/ReWOO-Demo/alpaca/utils/prompter.py
+++ /dev/null
@@ -1,53 +0,0 @@
-"""
-A dedicated helper to manage templates and prompt building.
-"""
-
-import json
-import os
-import os.path as osp
-from typing import Union
-
-
-class Prompter(object):
-    __slots__ = ("template", "_verbose")
-
-    def __init__(self, template_name: str = "", verbose: bool = False):
-        self._verbose = verbose
-        if not template_name:
-            # Enforce the default here, so the constructor can be called with '' and will not break.
-            template_name = "alpaca"
-        file_name = osp.join("alpaca/templates", f"{template_name}.json")
-        if not osp.exists(file_name):
-            print(os.listdir())
-            raise ValueError(f"Can't read {file_name}")
-        with open(file_name) as fp:
-            self.template = json.load(fp)
-        if self._verbose:
-            print(
-                f"Using prompt template {template_name}: {self.template['description']}"
-            )
-
-    def generate_prompt(
-        self,
-        instruction: str,
-        input: Union[None, str] = None,
-        label: Union[None, str] = None,
-    ) -> str:
-        # returns the full prompt from instruction and optional input
-        # if a label (=response, =output) is provided, it's also appended.
-        if input:
-            res = self.template["prompt_input"].format(
-                instruction=instruction, input=input
-            )
-        else:
-            res = self.template["prompt_no_input"].format(
-                instruction=instruction
-            )
-        if label:
-            res = f"{res}{label}"
-        if self._verbose:
-            print(res)
-        return res
-
-    def get_response(self, output: str) -> str:
-        return output.split(self.template["response_split"])[1].strip()
diff --git a/spaces/rgres/Seg2Sat/README.md b/spaces/rgres/Seg2Sat/README.md
deleted file mode 100644
index 9f9ece6b7aacddb6e8a1044101c1d1e74bbf6033..0000000000000000000000000000000000000000
--- a/spaces/rgres/Seg2Sat/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Seg2Sat
-emoji: 🎨
-colorFrom: blue
-colorTo: green
-sdk: docker
-pinned: true
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/rgres/Seg2Sat/frontend/.svelte-kit/output/client/_app/immutable/start-83af0c6f.js b/spaces/rgres/Seg2Sat/frontend/.svelte-kit/output/client/_app/immutable/start-83af0c6f.js
deleted file mode 100644
index 6b8c5e458163b3c9089f19fde3b95f587860762f..0000000000000000000000000000000000000000
--- a/spaces/rgres/Seg2Sat/frontend/.svelte-kit/output/client/_app/immutable/start-83af0c6f.js
+++ /dev/null
@@ -1 +0,0 @@
-import{S as Ye,i as Ge,s as Me,e as Fe,c as Xe,a as He,d as D,b as me,f as K,g as V,t as Ze,h as Qe,j as et,k as tt,l as P,m as nt,n as Y,o as C,p as G,q as T,r as st,u as rt,v as ye,w as z,x as ne,y as q,z as se,A as re,B as J,C as ie,D as Ce}from"./chunks/index-bcf2726a.js";import{s as it,w as ce,a as at}from"./chunks/paths-d3bcbd10.js";function ot(s){let e,t,i;const l=[s[1]||{}];var c=s[0][0];function f(n){let r={};for(let a=0;a<l.length;a+=1)r=ie(r,l[a]);return{props:r}}return c&&(e=new c(f())),{c(){e&&z(e.$$.fragment),t=P()},l(n){e&&ne(e.$$.fragment,n),t=P()},m(n,r){e&&q(e,n,r),V(n,t,r),i=!0},p(n,r){const a=r&2?se(l,[re(n[1]||{})]):{};if(c!==(c=n[0][0])){if(e){Y();const d=e;C(d.$$.fragment,1,0,()=>{J(d,1)}),G()}c?(e=new c(f()),z(e.$$.fragment),T(e.$$.fragment,1),q(e,t.parentNode,t)):e=null}else c&&e.$set(a)},i(n){i||(e&&T(e.$$.fragment,n),i=!0)},o(n){e&&C(e.$$.fragment,n),i=!1},d(n){n&&D(t),e&&J(e,n)}}}function ct(s){let e,t,i;const l=[s[1]||{}];var c=s[0][0];function f(n){let r={$$slots:{default:[dt]},$$scope:{ctx:n}};for(let a=0;a<l.length;a+=1)r=ie(r,l[a]);return{props:r}}return c&&(e=new c(f(s))),{c(){e&&z(e.$$.fragment),t=P()},l(n){e&&ne(e.$$.fragment,n),t=P()},m(n,r){e&&q(e,n,r),V(n,t,r),i=!0},p(n,r){const a=r&2?se(l,[re(n[1]||{})]):{};if(r&525&&(a.$$scope={dirty:r,ctx:n}),c!==(c=n[0][0])){if(e){Y();const d=e;C(d.$$.fragment,1,0,()=>{J(d,1)}),G()}c?(e=new c(f(n)),z(e.$$.fragment),T(e.$$.fragment,1),q(e,t.parentNode,t)):e=null}else c&&e.$set(a)},i(n){i||(e&&T(e.$$.fragment,n),i=!0)},o(n){e&&C(e.$$.fragment,n),i=!1},d(n){n&&D(t),e&&J(e,n)}}}function lt(s){let e,t,i;const l=[s[2]||{}];var c=s[0][1];function f(n){let r={};for(let a=0;a<l.length;a+=1)r=ie(r,l[a]);return{props:r}}return c&&(e=new c(f())),{c(){e&&z(e.$$.fragment),t=P()},l(n){e&&ne(e.$$.fragment,n),t=P()},m(n,r){e&&q(e,n,r),V(n,t,r),i=!0},p(n,r){const a=r&4?se(l,[re(n[2]||{})]):{};if(c!==(c=n[0][1])){if(e){Y();const d=e;C(d.$$.fragment,1,0,()=>{J(d,1)}),G()}c?(e=new c(f()),z(e.$$.fragment),T(e.$$.fragment,1),q(e,t.parentNode,t)):e=null}else c&&e.$set(a)},i(n){i||(e&&T(e.$$.fragment,n),i=!0)},o(n){e&&C(e.$$.fragment,n),i=!1},d(n){n&&D(t),e&&J(e,n)}}}function ft(s){let e,t,i;const l=[s[2]||{}];var c=s[0][1];function f(n){let r={$$slots:{default:[ut]},$$scope:{ctx:n}};for(let a=0;a<l.length;a+=1)r=ie(r,l[a]);return{props:r}}return c&&(e=new c(f(s))),{c(){e&&z(e.$$.fragment),t=P()},l(n){e&&ne(e.$$.fragment,n),t=P()},m(n,r){e&&q(e,n,r),V(n,t,r),i=!0},p(n,r){const a=r&4?se(l,[re(n[2]||{})]):{};if(r&521&&(a.$$scope={dirty:r,ctx:n}),c!==(c=n[0][1])){if(e){Y();const d=e;C(d.$$.fragment,1,0,()=>{J(d,1)}),G()}c?(e=new c(f(n)),z(e.$$.fragment),T(e.$$.fragment,1),q(e,t.parentNode,t)):e=null}else c&&e.$set(a)},i(n){i||(e&&T(e.$$.fragment,n),i=!0)},o(n){e&&C(e.$$.fragment,n),i=!1},d(n){n&&D(t),e&&J(e,n)}}}function ut(s){let e,t,i;const l=[s[3]||{}];var c=s[0][2];function f(n){let r={};for(let a=0;a<l.length;a+=1)r=ie(r,l[a]);return{props:r}}return c&&(e=new c(f())),{c(){e&&z(e.$$.fragment),t=P()},l(n){e&&ne(e.$$.fragment,n),t=P()},m(n,r){e&&q(e,n,r),V(n,t,r),i=!0},p(n,r){const a=r&8?se(l,[re(n[3]||{})]):{};if(c!==(c=n[0][2])){if(e){Y();const d=e;C(d.$$.fragment,1,0,()=>{J(d,1)}),G()}c?(e=new c(f()),z(e.$$.fragment),T(e.$$.fragment,1),q(e,t.parentNode,t)):e=null}else c&&e.$set(a)},i(n){i||(e&&T(e.$$.fragment,n),i=!0)},o(n){e&&C(e.$$.fragment,n),i=!1},d(n){n&&D(t),e&&J(e,n)}}}function dt(s){let e,t,i,l;const c=[ft,lt],f=[];function n(r,a){return r[0][2]?0:1}return e=n(s),t=f[e]=c[e](s),{c(){t.c(),i=P()},l(r){t.l(r),i=P()},m(r,a){f[e].m(r,a),V(r,i,a),l=!0},p(r,a){let d=e;e=n(r),e===d?f[e].p(r,a):(Y(),C(f[d],1,1,()=>{f[d]=null}),G(),t=f[e],t?t.p(r,a):(t=f[e]=c[e](r),t.c()),T(t,1),t.m(i.parentNode,i))},i(r){l||(T(t),l=!0)},o(r){C(t),l=!1},d(r){f[e].d(r),r&&D(i)}}}function Te(s){let e,t=s[5]&&je(s);return{c(){e=Fe("div"),t&&t.c(),this.h()},l(i){e=Xe(i,"DIV",{id:!0,"aria-live":!0,"aria-atomic":!0,style:!0});var l=He(e);t&&t.l(l),l.forEach(D),this.h()},h(){me(e,"id","svelte-announcer"),me(e,"aria-live","assertive"),me(e,"aria-atomic","true"),K(e,"position","absolute"),K(e,"left","0"),K(e,"top","0"),K(e,"clip","rect(0 0 0 0)"),K(e,"clip-path","inset(50%)"),K(e,"overflow","hidden"),K(e,"white-space","nowrap"),K(e,"width","1px"),K(e,"height","1px")},m(i,l){V(i,e,l),t&&t.m(e,null)},p(i,l){i[5]?t?t.p(i,l):(t=je(i),t.c(),t.m(e,null)):t&&(t.d(1),t=null)},d(i){i&&D(e),t&&t.d()}}}function je(s){let e;return{c(){e=Ze(s[6])},l(t){e=Qe(t,s[6])},m(t,i){V(t,e,i)},p(t,i){i&64&&et(e,t[6])},d(t){t&&D(e)}}}function pt(s){let e,t,i,l,c;const f=[ct,ot],n=[];function r(d,L){return d[0][1]?0:1}e=r(s),t=n[e]=f[e](s);let a=s[4]&&Te(s);return{c(){t.c(),i=tt(),a&&a.c(),l=P()},l(d){t.l(d),i=nt(d),a&&a.l(d),l=P()},m(d,L){n[e].m(d,L),V(d,i,L),a&&a.m(d,L),V(d,l,L),c=!0},p(d,[L]){let E=e;e=r(d),e===E?n[e].p(d,L):(Y(),C(n[E],1,1,()=>{n[E]=null}),G(),t=n[e],t?t.p(d,L):(t=n[e]=f[e](d),t.c()),T(t,1),t.m(i.parentNode,i)),d[4]?a?a.p(d,L):(a=Te(d),a.c(),a.m(l.parentNode,l)):a&&(a.d(1),a=null)},i(d){c||(T(t),c=!0)},o(d){C(t),c=!1},d(d){n[e].d(d),d&&D(i),a&&a.d(d),d&&D(l)}}}function ht(s,e,t){let{stores:i}=e,{page:l}=e,{components:c}=e,{props_0:f=null}=e,{props_1:n=null}=e,{props_2:r=null}=e;st("__svelte__",i),rt(i.page.notify);let a=!1,d=!1,L=null;return ye(()=>{const E=i.page.subscribe(()=>{a&&(t(5,d=!0),t(6,L=document.title||"untitled page"))});return t(4,a=!0),E}),s.$$set=E=>{"stores"in E&&t(7,i=E.stores),"page"in E&&t(8,l=E.page),"components"in E&&t(0,c=E.components),"props_0"in E&&t(1,f=E.props_0),"props_1"in E&&t(2,n=E.props_1),"props_2"in E&&t(3,r=E.props_2)},s.$$.update=()=>{s.$$.dirty&384&&i.page.set(l)},[c,f,n,r,a,d,L,i,l]}class _t extends Ye{constructor(e){super(),Ge(this,e,ht,pt,Me,{stores:7,page:8,components:0,props_0:1,props_1:2,props_2:3})}}const mt="modulepreload",Ie={},gt="/static/_app/immutable/",ge=function(e,t){return!t||t.length===0?e():Promise.all(t.map(i=>{if(i=`${gt}${i}`,i in Ie)return;Ie[i]=!0;const l=i.endsWith(".css"),c=l?'[rel="stylesheet"]':"";if(document.querySelector(`link[href="${i}"]${c}`))return;const f=document.createElement("link");if(f.rel=l?"stylesheet":mt,l||(f.as="script",f.crossOrigin=""),f.href=i,document.head.appendChild(f),l)return new Promise((n,r)=>{f.addEventListener("load",n),f.addEventListener("error",()=>r(new Error(`Unable to preload CSS for ${i}`)))})})).then(()=>e())},wt={},le=[()=>ge(()=>import("./pages/__layout.svelte-f5a1b718.js"),["pages/__layout.svelte-f5a1b718.js","assets/pages/__layout.svelte-b67cf61d.css","chunks/index-bcf2726a.js"]),()=>ge(()=>import("./error.svelte-d9523301.js"),["error.svelte-d9523301.js","chunks/index-bcf2726a.js"]),()=>ge(()=>import("./pages/index.svelte-ce916c65.js"),["pages/index.svelte-ce916c65.js","assets/pages/index.svelte-f2b33456.css","chunks/index-bcf2726a.js","chunks/paths-d3bcbd10.js"])],bt={"":[[0,2],[1]]};function yt(s){s.client}function De(s){return s instanceof Error||s&&s.name&&s.message?s:new Error(JSON.stringify(s))}function Ve(s){if(s.fallthrough)throw new Error("fallthrough is no longer supported. Use matchers instead: https://kit.svelte.dev/docs/routing#advanced-routing-matching");if("maxage"in s)throw new Error("maxage should be replaced with cache: { maxage }");const e=s.status&&s.status>=400&&s.status<=599&&!s.redirect;if(s.error||e){const t=s.status;if(!s.error&&e)return{status:t||500,error:new Error};const i=typeof s.error=="string"?new Error(s.error):s.error;return i instanceof Error?!t||t<400||t>599?(console.warn('"error" returned from load() without a valid status code \u2014 defaulting to 500'),{status:500,error:i}):{status:t,error:i}:{status:500,error:new Error(`"error" property returned from load() must be a string or instance of Error, received type "${typeof i}"`)}}if(s.redirect){if(!s.status||Math.floor(s.status/100)!==3)throw new Error('"redirect" property returned from load() must be accompanied by a 3xx status code');if(typeof s.redirect!="string")throw new Error('"redirect" property returned from load() must be a string')}if(s.dependencies&&(!Array.isArray(s.dependencies)||s.dependencies.some(t=>typeof t!="string")))throw new Error('"dependencies" property returned from load() must be of type string[]');if(s.context)throw new Error('You are returning "context" from a load function. "context" was renamed to "stuff", please adjust your code accordingly.');return s}function vt(s,e){return s==="/"||e==="ignore"?s:e==="never"?s.endsWith("/")?s.slice(0,-1):s:e==="always"&&!s.endsWith("/")?s+"/":s}class $t extends URL{get hash(){throw new Error("url.hash is inaccessible from load. Consider accessing hash from the page store within the script tag of your component.")}}function ze(s){let e=s.baseURI;if(!e){const t=s.getElementsByTagName("base");e=t.length?t[0].href:s.URL}return e}function ve(){return{x:pageXOffset,y:pageYOffset}}function qe(s){return s.composedPath().find(t=>t instanceof Node&&t.nodeName.toUpperCase()==="A")}function Je(s){return s instanceof SVGAElement?new URL(s.href.baseVal,document.baseURI):new URL(s.href)}function Ke(s){const e=ce(s);let t=!0;function i(){t=!0,e.update(f=>f)}function l(f){t=!1,e.set(f)}function c(f){let n;return e.subscribe(r=>{(n===void 0||t&&r!==n)&&f(n=r)})}return{notify:i,set:l,subscribe:c}}function kt(){const{set:s,subscribe:e}=ce(!1),t="1685815788294";let i;async function l(){clearTimeout(i);const f=await fetch(`${at}/_app/version.json`,{headers:{pragma:"no-cache","cache-control":"no-cache"}});if(f.ok){const{version:n}=await f.json(),r=n!==t;return r&&(s(!0),clearTimeout(i)),r}else throw new Error(`Version check failed: ${f.status}`)}return{subscribe:e,check:l}}function Et(s){let e=5381,t=s.length;if(typeof s=="string")for(;t;)e=e*33^s.charCodeAt(--t);else for(;t;)e=e*33^s[--t];return(e>>>0).toString(36)}const $e=window.fetch;function Rt(s,e){let i=`script[sveltekit\\:data-type="data"][sveltekit\\:data-url=${JSON.stringify(typeof s=="string"?s:s.url)}]`;e&&typeof e.body=="string"&&(i+=`[sveltekit\\:data-body="${Et(e.body)}"]`);const l=document.querySelector(i);if(l&&l.textContent){const{body:c,...f}=JSON.parse(l.textContent);return Promise.resolve(new Response(c,f))}return $e(s,e)}const Lt=/^(\.\.\.)?(\w+)(?:=(\w+))?$/;function St(s){const e=[],t=[];let i=!0;return{pattern:s===""?/^\/$/:new RegExp(`^${decodeURIComponent(s).split(/(?:@[a-zA-Z0-9_-]+)?(?:\/|$)/).map((c,f,n)=>{const r=/^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(c);if(r)return e.push(r[1]),t.push(r[2]),"(?:/(.*))?";const a=f===n.length-1;return c&&"/"+c.split(/\[(.+?)\]/).map((d,L)=>{if(L%2){const[,E,X,M]=Lt.exec(d);return e.push(X),t.push(M),E?"(.*?)":"([^/]+?)"}return a&&d.includes(".")&&(i=!1),d.normalize().replace(/%5[Bb]/g,"[").replace(/%5[Dd]/g,"]").replace(/#/g,"%23").replace(/\?/g,"%3F").replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}).join("")}).join("")}${i?"/?":""}$`),names:e,types:t}}function Ut(s,e,t,i){const l={};for(let c=0;c<e.length;c+=1){const f=e[c],n=t[c],r=s[c+1]||"";if(n){const a=i[n];if(!a)throw new Error(`Missing "${n}" param matcher`);if(!a(r))return}l[f]=r}return l}function At(s,e,t){return Object.entries(e).map(([l,[c,f,n]])=>{const{pattern:r,names:a,types:d}=St(l);return{id:l,exec:L=>{const E=r.exec(L);if(E)return Ut(E,a,d,t)},a:c.map(L=>s[L]),b:f.map(L=>s[L]),has_shadow:!!n}})}const We="sveltekit:scroll",B="sveltekit:index",we=At(le,bt,wt),Nt=le[0](),Ot=le[1](),Be={};let te={};try{te=JSON.parse(sessionStorage[We])}catch{}function be(s){te[s]=ve()}function xt({target:s,session:e,base:t,trailing_slash:i}){var xe;const l=new Map,c=[],f={url:Ke({}),page:Ke({}),navigating:ce(null),session:ce(e),updated:kt()},n={id:null,promise:null},r={before_navigate:[],after_navigate:[]};let a={branch:[],error:null,session_id:0,stuff:Be,url:null},d=!1,L=!0,E=!1,X=1,M=null,ke,Ee,Re=!1;f.session.subscribe(async o=>{Ee=o,Re&&(X+=1,pe(new URL(location.href),[],!0))}),Re=!0;let F=!0,j=(xe=history.state)==null?void 0:xe[B];j||(j=Date.now(),history.replaceState({...history.state,[B]:j},"",location.href));const fe=te[j];fe&&(history.scrollRestoration="manual",scrollTo(fe.x,fe.y));let ue=!1,de,Le;async function Se(o,{noscroll:p=!1,replaceState:w=!1,keepfocus:u=!1,state:h={}},b){if(typeof o=="string"&&(o=new URL(o,ze(document))),F)return _e({url:o,scroll:p?ve():null,keepfocus:u,redirect_chain:b,details:{state:h,replaceState:w},accepted:()=>{},blocked:()=>{}});await Q(o)}async function Ue(o){const p=Oe(o);if(!p)throw new Error("Attempted to prefetch a URL that does not belong to this app");return n.promise=Ne(p,!1),n.id=p.id,n.promise}async function pe(o,p,w,u,h){var R,S,N;const b=Oe(o),v=Le={};let _=b&&await Ne(b,w);if(!_&&o.origin===location.origin&&o.pathname===location.pathname&&(_=await Z({status:404,error:new Error(`Not found: ${o.pathname}`),url:o,routeId:null})),!_)return await Q(o),!1;if(Le!==v)return!1;if(c.length=0,_.redirect)if(p.length>10||p.includes(o.pathname))_=await Z({status:500,error:new Error("Redirect loop"),url:o,routeId:null});else return F?Se(new URL(_.redirect,o).href,{},[...p,o.pathname]):await Q(new URL(_.redirect,location.href)),!1;else((S=(R=_.props)==null?void 0:R.page)==null?void 0:S.status)>=400&&await f.updated.check()&&await Q(o);if(E=!0,u&&u.details){const{details:$}=u,y=$.replaceState?0:1;$.state[B]=j+=y,history[$.replaceState?"replaceState":"pushState"]($.state,"",o)}if(d?(a=_.state,_.props.page&&(_.props.page.url=o),ke.$set(_.props)):Ae(_),u){const{scroll:$,keepfocus:y}=u;if(!y){const U=document.body,g=U.getAttribute("tabindex");(N=getSelection())==null||N.removeAllRanges(),U.tabIndex=-1,U.focus({preventScroll:!0}),g!==null?U.setAttribute("tabindex",g):U.removeAttribute("tabindex")}if(await Ce(),L){const U=o.hash&&document.getElementById(o.hash.slice(1));$?scrollTo($.x,$.y):U?U.scrollIntoView():scrollTo(0,0)}}else await Ce();n.promise=null,n.id=null,L=!0,_.props.page&&(de=_.props.page);const m=_.state.branch[_.state.branch.length-1];F=(m==null?void 0:m.module.router)!==!1,h&&h(),E=!1}function Ae(o){a=o.state;const p=document.querySelector("style[data-sveltekit]");if(p&&p.remove(),de=o.props.page,ke=new _t({target:s,props:{...o.props,stores:f},hydrate:!0}),F){const w={from:null,to:new URL(location.href)};r.after_navigate.forEach(u=>u(w))}d=!0}async function he({url:o,params:p,stuff:w,branch:u,status:h,error:b,routeId:v}){var y,U;const _=u.filter(Boolean),m=_.find(g=>{var O;return(O=g.loaded)==null?void 0:O.redirect}),R={redirect:(y=m==null?void 0:m.loaded)==null?void 0:y.redirect,state:{url:o,params:p,branch:u,error:b,stuff:w,session_id:X},props:{components:_.map(g=>g.module.default)}};for(let g=0;g<_.length;g+=1){const O=_[g].loaded;R.props[`props_${g}`]=O?await O.props:null}if(!a.url||o.href!==a.url.href||a.error!==b||a.stuff!==w){R.props.page={error:b,params:p,routeId:v,status:h,stuff:w,url:o};const g=(O,k)=>{Object.defineProperty(R.props.page,O,{get:()=>{throw new Error(`$page.${O} has been replaced by $page.url.${k}`)}})};g("origin","origin"),g("path","pathname"),g("query","searchParams")}const N=_[_.length-1],$=(U=N==null?void 0:N.loaded)==null?void 0:U.cache;if($){const g=o.pathname+o.search;let O=!1;const k=()=>{l.get(g)===R&&l.delete(g),x(),clearTimeout(A)},A=setTimeout(k,$.maxage*1e3),x=f.session.subscribe(()=>{O&&k()});O=!0,l.set(g,R)}return R}async function H({status:o,error:p,module:w,url:u,params:h,stuff:b,props:v,routeId:_}){const m={module:w,uses:{params:new Set,url:!1,session:!1,stuff:!1,dependencies:new Set},loaded:null,stuff:b};function R(y){const{href:U}=new URL(y,u);m.uses.dependencies.add(U)}v&&m.uses.dependencies.add(u.href);const S={};for(const y in h)Object.defineProperty(S,y,{get(){return m.uses.params.add(y),h[y]},enumerable:!0});const N=Ee,$=new $t(u);if(w.load){const y={routeId:_,params:S,props:v||{},get url(){return m.uses.url=!0,$},get session(){return m.uses.session=!0,N},get stuff(){return m.uses.stuff=!0,{...b}},async fetch(g,O){let k;typeof g=="string"?k=g:(k=g.url,O={body:g.method==="GET"||g.method==="HEAD"?void 0:await g.blob(),cache:g.cache,credentials:g.credentials,headers:g.headers,integrity:g.integrity,keepalive:g.keepalive,method:g.method,mode:g.mode,redirect:g.redirect,referrer:g.referrer,referrerPolicy:g.referrerPolicy,signal:g.signal,...O});const A=new URL(k,u).href;return R(A),d?$e(A,O):Rt(k,O)},status:o!=null?o:null,error:p!=null?p:null};let U;if(U=await w.load.call(null,y),!U)throw new Error("load function must return a value");m.loaded=Ve(U),m.loaded.stuff&&(m.stuff=m.loaded.stuff),m.loaded.dependencies&&m.loaded.dependencies.forEach(R)}else v&&(m.loaded=Ve({props:v}));return m}async function Ne({id:o,url:p,params:w,route:u},h){var U,g,O;if(n.id===o&&n.promise)return n.promise;if(!h){const k=l.get(o);if(k)return k}const{a:b,b:v,has_shadow:_}=u,m=a.url&&{url:o!==a.url.pathname+a.url.search,params:Object.keys(w).filter(k=>a.params[k]!==w[k]),session:X!==a.session_id};let R=[],S=Be,N=!1,$=200,y=null;b.forEach(k=>k().catch(()=>{}));e:for(let k=0;k<b.length;k+=1){let A;try{if(!b[k])continue;const x=await b[k](),I=a.branch[k];if(!I||x!==I.module||m.url&&I.uses.url||m.params.some(W=>I.uses.params.has(W))||m.session&&I.uses.session||Array.from(I.uses.dependencies).some(W=>c.some(oe=>oe(W)))||N&&I.uses.stuff){let W={};const oe=_&&k===b.length-1;if(oe){const ee=await $e(`${p.pathname}${p.pathname.endsWith("/")?"":"/"}__data.json${p.search}`,{headers:{"x-sveltekit-load":"true"}});if(ee.ok){const Pe=ee.headers.get("x-sveltekit-location");if(Pe)return{redirect:Pe,props:{},state:a};W=ee.status===204?{}:await ee.json()}else $=ee.status,y=new Error("Failed to load data")}if(y||(A=await H({module:x,url:p,params:w,props:W,stuff:S,routeId:u.id})),A&&(oe&&(A.uses.url=!0),A.loaded)){if(A.loaded.error&&($=A.loaded.status,y=A.loaded.error),A.loaded.redirect)return{redirect:A.loaded.redirect,props:{},state:a};A.loaded.stuff&&(N=!0)}}else A=I}catch(x){$=500,y=De(x)}if(y){for(;k--;)if(v[k]){let x,I,ae=k;for(;!(I=R[ae]);)ae-=1;try{if(x=await H({status:$,error:y,module:await v[k](),url:p,params:w,stuff:I.stuff,routeId:u.id}),(U=x==null?void 0:x.loaded)!=null&&U.error)continue;(g=x==null?void 0:x.loaded)!=null&&g.stuff&&(S={...S,...x.loaded.stuff}),R=R.slice(0,ae+1).concat(x);break e}catch{continue}}return await Z({status:$,error:y,url:p,routeId:u.id})}else(O=A==null?void 0:A.loaded)!=null&&O.stuff&&(S={...S,...A.loaded.stuff}),R.push(A)}return await he({url:p,params:w,stuff:S,branch:R,status:$,error:y,routeId:u.id})}async function Z({status:o,error:p,url:w,routeId:u}){var _,m;const h={},b=await H({module:await Nt,url:w,params:h,stuff:{},routeId:u}),v=await H({status:o,error:p,module:await Ot,url:w,params:h,stuff:b&&b.loaded&&b.loaded.stuff||{},routeId:u});return await he({url:w,params:h,stuff:{...(_=b==null?void 0:b.loaded)==null?void 0:_.stuff,...(m=v==null?void 0:v.loaded)==null?void 0:m.stuff},branch:[b,v],status:o,error:p,routeId:u})}function Oe(o){if(o.origin!==location.origin||!o.pathname.startsWith(t))return;const p=decodeURI(o.pathname.slice(t.length)||"/");for(const w of we){const u=w.exec(p);if(u)return{id:o.pathname+o.search,route:w,params:u,url:o}}}async function _e({url:o,scroll:p,keepfocus:w,redirect_chain:u,details:h,accepted:b,blocked:v}){const _=a.url;let m=!1;const R={from:_,to:o,cancel:()=>m=!0};if(r.before_navigate.forEach($=>$(R)),m){v();return}const S=vt(o.pathname,i),N=new URL(o.origin+S+o.search+o.hash);be(j),b(),d&&f.navigating.set({from:a.url,to:N}),await pe(N,u,!1,{scroll:p,keepfocus:w,details:h},()=>{const $={from:_,to:N};r.after_navigate.forEach(y=>y($)),f.navigating.set(null)})}function Q(o){return location.href=o.href,new Promise(()=>{})}return{after_navigate:o=>{ye(()=>(r.after_navigate.push(o),()=>{const p=r.after_navigate.indexOf(o);r.after_navigate.splice(p,1)}))},before_navigate:o=>{ye(()=>(r.before_navigate.push(o),()=>{const p=r.before_navigate.indexOf(o);r.before_navigate.splice(p,1)}))},disable_scroll_handling:()=>{(E||!d)&&(L=!1)},goto:(o,p={})=>Se(o,p,[]),invalidate:o=>{if(typeof o=="function")c.push(o);else{const{href:p}=new URL(o,location.href);c.push(w=>w===p)}return M||(M=Promise.resolve().then(async()=>{await pe(new URL(location.href),[],!0),M=null})),M},prefetch:async o=>{const p=new URL(o,ze(document));await Ue(p)},prefetch_routes:async o=>{const w=(o?we.filter(u=>o.some(h=>u.exec(h))):we).map(u=>Promise.all(u.a.map(h=>h())));await Promise.all(w)},_start_router:()=>{history.scrollRestoration="manual",addEventListener("beforeunload",u=>{let h=!1;const b={from:a.url,to:null,cancel:()=>h=!0};r.before_navigate.forEach(v=>v(b)),h?(u.preventDefault(),u.returnValue=""):history.scrollRestoration="auto"}),addEventListener("visibilitychange",()=>{if(document.visibilityState==="hidden"){be(j);try{sessionStorage[We]=JSON.stringify(te)}catch{}}});const o=u=>{const h=qe(u);h&&h.href&&h.hasAttribute("sveltekit:prefetch")&&Ue(Je(h))};let p;const w=u=>{clearTimeout(p),p=setTimeout(()=>{var h;(h=u.target)==null||h.dispatchEvent(new CustomEvent("sveltekit:trigger_prefetch",{bubbles:!0}))},20)};addEventListener("touchstart",o),addEventListener("mousemove",w),addEventListener("sveltekit:trigger_prefetch",o),addEventListener("click",u=>{if(!F||u.button||u.which!==1||u.metaKey||u.ctrlKey||u.shiftKey||u.altKey||u.defaultPrevented)return;const h=qe(u);if(!h||!h.href)return;const b=h instanceof SVGAElement,v=Je(h);if(!b&&v.origin==="null")return;const _=(h.getAttribute("rel")||"").split(/\s+/);if(h.hasAttribute("download")||_.includes("external")||h.hasAttribute("sveltekit:reload")||(b?h.target.baseVal:h.target))return;const[m,R]=v.href.split("#");if(R!==void 0&&m===location.href.split("#")[0]){ue=!0,be(j),f.page.set({...de,url:v}),f.page.notify();return}_e({url:v,scroll:h.hasAttribute("sveltekit:noscroll")?ve():null,keepfocus:!1,redirect_chain:[],details:{state:{},replaceState:v.href===location.href},accepted:()=>u.preventDefault(),blocked:()=>u.preventDefault()})}),addEventListener("popstate",u=>{if(u.state&&F){if(u.state[B]===j)return;_e({url:new URL(location.href),scroll:te[u.state[B]],keepfocus:!1,redirect_chain:[],details:null,accepted:()=>{j=u.state[B]},blocked:()=>{const h=j-u.state[B];history.go(h)}})}}),addEventListener("hashchange",()=>{ue&&(ue=!1,history.replaceState({...history.state,[B]:++j},"",location.href))})},_hydrate:async({status:o,error:p,nodes:w,params:u,routeId:h})=>{const b=new URL(location.href),v=[];let _={},m,R;try{for(let S=0;S<w.length;S+=1){const N=S===w.length-1;let $;if(N){const U=document.querySelector('script[sveltekit\\:data-type="props"]');U&&($=JSON.parse(U.textContent))}const y=await H({module:await le[w[S]](),url:b,params:u,stuff:_,status:N?o:void 0,error:N?p:void 0,props:$,routeId:h});if($&&(y.uses.dependencies.add(b.href),y.uses.url=!0),v.push(y),y&&y.loaded)if(y.loaded.error){if(p)throw y.loaded.error;R={status:y.loaded.status,error:y.loaded.error,url:b,routeId:h}}else y.loaded.stuff&&(_={..._,...y.loaded.stuff})}m=R?await Z(R):await he({url:b,params:u,stuff:_,branch:v,status:o,error:p,routeId:h})}catch(S){if(p)throw S;m=await Z({status:500,error:De(S),url:b,routeId:h})}m.redirect&&await Q(new URL(m.redirect,location.href)),Ae(m)}}}async function Tt({paths:s,target:e,session:t,route:i,spa:l,trailing_slash:c,hydrate:f}){const n=xt({target:e,session:t,base:s.base,trailing_slash:c});yt({client:n}),it(s),f&&await n._hydrate(f),i&&(l&&n.goto(location.href,{replaceState:!0}),n._start_router()),dispatchEvent(new CustomEvent("sveltekit:start"))}export{Tt as start};
diff --git a/spaces/rodevel1978/llama-2-13b-chat.ggmlv3.q4_K_S/USE_POLICY.md b/spaces/rodevel1978/llama-2-13b-chat.ggmlv3.q4_K_S/USE_POLICY.md
deleted file mode 100644
index abbcc199b2d1e4feb5d7e40c0bd67e1b0ce29e97..0000000000000000000000000000000000000000
--- a/spaces/rodevel1978/llama-2-13b-chat.ggmlv3.q4_K_S/USE_POLICY.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# Llama 2 Acceptable Use Policy
-
-Meta is committed to promoting safe and fair use of its tools and features, including Llama 2. If you access or use Llama 2, you agree to this Acceptable Use Policy (“Policy”). The most recent copy of this policy can be found at [ai.meta.com/llama/use-policy](http://ai.meta.com/llama/use-policy).
-
-## Prohibited Uses
-We want everyone to use Llama 2 safely and responsibly. You agree you will not use, or allow others to use, Llama 2 to: 
-
-1. Violate the law or others’ rights, including to:
-    1. Engage in, promote, generate, contribute to, encourage, plan, incite, or further illegal or unlawful activity or content, such as: 
-        1. Violence or terrorism 
-        2. Exploitation or harm to children, including the solicitation, creation, acquisition, or dissemination of child exploitative content or failure to report Child Sexual Abuse Material
-        3. Human trafficking, exploitation, and sexual violence
-        4. The illegal distribution of information or materials to minors, including obscene materials, or failure to employ legally required age-gating in connection with such information or materials.
-        5. Sexual solicitation
-        6. Any other criminal activity
-    2. Engage in, promote, incite, or facilitate the harassment, abuse, threatening, or bullying of individuals or groups of individuals
-    3. Engage in, promote, incite, or facilitate discrimination or other unlawful or harmful conduct in the provision of employment, employment benefits, credit, housing, other economic benefits, or other essential goods and services
-    4. Engage in the unauthorized or unlicensed practice of any profession including, but not limited to, financial, legal, medical/health, or related professional practices 
-    5. Collect, process, disclose, generate, or infer health, demographic, or other sensitive personal or private information about individuals without rights and consents required by applicable laws
-    6. Engage in or facilitate any action or generate any content that infringes, misappropriates, or otherwise violates any third-party rights, including the outputs or results of any products or services using the Llama 2 Materials
-    7. Create, generate, or facilitate the creation of malicious code, malware, computer viruses or do anything else that could disable, overburden, interfere with or impair the proper working, integrity, operation or appearance of a website or computer system 
-
-
-
-2. Engage in, promote, incite, facilitate, or assist in the planning or development of activities that present a risk of death or bodily harm to individuals, including use of Llama 2 related to the following:
-    1. Military, warfare, nuclear industries or applications, espionage, use for materials or activities that are subject to the International Traffic Arms Regulations (ITAR) maintained by the United States Department of State
-    2. Guns and illegal weapons (including weapon development)
-    3. Illegal drugs and regulated/controlled substances
-    4. Operation of critical infrastructure, transportation technologies, or heavy machinery
-    5. Self-harm or harm to others, including suicide, cutting, and eating disorders
-    6. Any content intended to incite or promote violence, abuse, or any infliction of bodily harm to an individual
-
-
-
-3. Intentionally deceive or mislead others, including use of Llama 2 related to the following:
-    1. Generating, promoting, or furthering fraud or the creation or promotion of disinformation
-    2. Generating, promoting, or furthering defamatory content, including the creation of defamatory statements, images, or other content
-    3. Generating, promoting, or further distributing spam
-    4. Impersonating another individual without consent, authorization, or legal right
-    5. Representing that the use of Llama 2 or outputs are human-generated
-    6. Generating or facilitating false online engagement, including fake reviews and other means of fake online engagement 
-4. Fail to appropriately disclose to end users any known dangers of your AI system 
-
-Please report any violation of this Policy, software “bug,” or other problems that could lead to a violation of this Policy through one of the following means:
-
-* Reporting issues with the model: [github.com/facebookresearch/llama](http://github.com/facebookresearch/llama)
-* Reporting risky content generated by the model: [developers.facebook.com/llama_output_feedback](http://developers.facebook.com/llama_output_feedback)
-* Reporting bugs and security concerns: [facebook.com/whitehat/info](http://facebook.com/whitehat/info)
-* Reporting violations of the Acceptable Use Policy or unlicensed uses of Llama: [LlamaUseReport@meta.com](mailto:LlamaUseReport@meta.com)
-
diff --git a/spaces/rorallitri/biomedical-language-models/logs/Bol Radha Bol 720p Hd Moviel The Story of a Village Belle and an Industrialist.md b/spaces/rorallitri/biomedical-language-models/logs/Bol Radha Bol 720p Hd Moviel The Story of a Village Belle and an Industrialist.md
deleted file mode 100644
index f6ec88821833c75109330e206b9b413e6e356b02..0000000000000000000000000000000000000000
--- a/spaces/rorallitri/biomedical-language-models/logs/Bol Radha Bol 720p Hd Moviel The Story of a Village Belle and an Industrialist.md	
+++ /dev/null
@@ -1,7 +0,0 @@
-
-<p>Bol radha bol is a 1992 hindi film directed by david dhawan and starring juhi chawla and rishi kapoor in the lead roles.the film is perhaps best remembered for the hit track "tu tu tu tara". the film was a big hit at the time of its release and was one of the highest grossing films of the year. juhi chawla received a filmfare best actress award nomination for her performance in the film.</p>
-<h2>Bol Radha Bol 720p Hd Moviel</h2><br /><p><b><b>Download</b> &#10003;&#10003;&#10003; <a href="https://tinurll.com/2uzmTR">https://tinurll.com/2uzmTR</a></b></p><br /><br />
-<p>Pyar hua, ikrar hua<br />Jeena yahan, marna yahan<br />In bahon ko, in rahon ko<br />Chod yeh chaliya jaye kahan<br />Mana dil toh hai anadi, yeh awara hi sahi<br />Aare bol radha bol sangam hoga ke nahin<br />Har janam mein, rang badal ke<br />Khwabon ke pardon pe hum khil ke<br />Hum hai rahi pyaar ke<br />Phir milenge chalte chalte<br />Hum hai rahi pyaar ke<br />Phir milenge chalte chalte</p>
-<p>nice song<br />Pyar hua, ikrar hua<br />Jeena yahan, marna yahan<br />In bahon ko, in rahon ko<br />Chod yeh chaliya jaye kahan<br />Mana dil toh hai anadi, yeh awara hi sahi<br />Aare bol radha bol sangam hoga ke nahin<br />Har janam mein, rang badal ke<br />Khwabon ke pardon pe hum khil ke<br />Hum hai rahi pyaar ke<br />Phir milenge chalte chalte<br />Hum hai rahi pyaar ke<br />Phir milenge chalte chalte<br />Dil ka bhawar kare, kare pukaar jab<br />Pyaar kisi se hota hai<br />Jeeya oh jeeya kuch bol do<br />Aab dard sa dil mein hota hai<br />Ohhh.. tere ghar ke samne</p> aaccfb2cb3<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/russellc/BLIP/models/nlvr_encoder.py b/spaces/russellc/BLIP/models/nlvr_encoder.py
deleted file mode 100644
index 1946bb4a300f75afa4848f6622839445903c34a9..0000000000000000000000000000000000000000
--- a/spaces/russellc/BLIP/models/nlvr_encoder.py
+++ /dev/null
@@ -1,843 +0,0 @@
-import math
-import os
-import warnings
-from dataclasses import dataclass
-from typing import Optional, Tuple
-
-import torch
-from torch import Tensor, device, dtype, nn
-import torch.utils.checkpoint
-from torch import nn
-from torch.nn import CrossEntropyLoss
-import torch.nn.functional as F
-
-from transformers.activations import ACT2FN
-from transformers.file_utils import (
-    ModelOutput,
-)
-from transformers.modeling_outputs import (
-    BaseModelOutputWithPastAndCrossAttentions,
-    BaseModelOutputWithPoolingAndCrossAttentions,
-    CausalLMOutputWithCrossAttentions,
-    MaskedLMOutput,
-    MultipleChoiceModelOutput,
-    NextSentencePredictorOutput,
-    QuestionAnsweringModelOutput,
-    SequenceClassifierOutput,
-    TokenClassifierOutput,
-)
-from transformers.modeling_utils import (
-    PreTrainedModel,
-    apply_chunking_to_forward,
-    find_pruneable_heads_and_indices,
-    prune_linear_layer,
-)
-from transformers.utils import logging
-from transformers.models.bert.configuration_bert import BertConfig
-
-
-logger = logging.get_logger(__name__)
-
-
-class BertEmbeddings(nn.Module):
-    """Construct the embeddings from word and position embeddings."""
-
-    def __init__(self, config):
-        super().__init__()
-        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
-        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
-
-        # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
-        # any TensorFlow checkpoint file
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
-        # position_ids (1, len position emb) is contiguous in memory and exported when serialized
-        self.register_buffer("position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)))
-        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
-        
-        self.config = config
-
-    def forward(
-        self, input_ids=None, position_ids=None, inputs_embeds=None, past_key_values_length=0
-    ):
-        if input_ids is not None:
-            input_shape = input_ids.size()
-        else:
-            input_shape = inputs_embeds.size()[:-1]
-
-        seq_length = input_shape[1]
-
-        if position_ids is None:
-            position_ids = self.position_ids[:, past_key_values_length : seq_length + past_key_values_length]
-
-        if inputs_embeds is None:
-            inputs_embeds = self.word_embeddings(input_ids)
-
-        embeddings = inputs_embeds
-
-        if self.position_embedding_type == "absolute":
-            position_embeddings = self.position_embeddings(position_ids)
-            embeddings += position_embeddings
-        embeddings = self.LayerNorm(embeddings)
-        embeddings = self.dropout(embeddings)
-        return embeddings
-
-
-class BertSelfAttention(nn.Module):
-    def __init__(self, config, is_cross_attention):
-        super().__init__()
-        self.config = config
-        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
-            raise ValueError(
-                "The hidden size (%d) is not a multiple of the number of attention "
-                "heads (%d)" % (config.hidden_size, config.num_attention_heads)
-            )
-        
-        self.num_attention_heads = config.num_attention_heads
-        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
-        self.all_head_size = self.num_attention_heads * self.attention_head_size
-
-        self.query = nn.Linear(config.hidden_size, self.all_head_size)
-        if is_cross_attention:
-            self.key = nn.Linear(config.encoder_width, self.all_head_size)
-            self.value = nn.Linear(config.encoder_width, self.all_head_size)
-        else:
-            self.key = nn.Linear(config.hidden_size, self.all_head_size)
-            self.value = nn.Linear(config.hidden_size, self.all_head_size)
-
-        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
-        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
-        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
-            self.max_position_embeddings = config.max_position_embeddings
-            self.distance_embedding = nn.Embedding(2 * config.max_position_embeddings - 1, self.attention_head_size)
-        self.save_attention = False   
-            
-    def save_attn_gradients(self, attn_gradients):
-        self.attn_gradients = attn_gradients
-        
-    def get_attn_gradients(self):
-        return self.attn_gradients
-    
-    def save_attention_map(self, attention_map):
-        self.attention_map = attention_map
-        
-    def get_attention_map(self):
-        return self.attention_map
-    
-    def transpose_for_scores(self, x):
-        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
-        x = x.view(*new_x_shape)
-        return x.permute(0, 2, 1, 3)
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_value=None,
-        output_attentions=False,
-    ):
-        mixed_query_layer = self.query(hidden_states)
-
-        # If this is instantiated as a cross-attention module, the keys
-        # and values come from an encoder; the attention mask needs to be
-        # such that the encoder's padding tokens are not attended to.
-        is_cross_attention = encoder_hidden_states is not None
-
-        if is_cross_attention:
-            key_layer = self.transpose_for_scores(self.key(encoder_hidden_states))
-            value_layer = self.transpose_for_scores(self.value(encoder_hidden_states))
-            attention_mask = encoder_attention_mask
-        elif past_key_value is not None:
-            key_layer = self.transpose_for_scores(self.key(hidden_states))
-            value_layer = self.transpose_for_scores(self.value(hidden_states))
-            key_layer = torch.cat([past_key_value[0], key_layer], dim=2)
-            value_layer = torch.cat([past_key_value[1], value_layer], dim=2)
-        else:
-            key_layer = self.transpose_for_scores(self.key(hidden_states))
-            value_layer = self.transpose_for_scores(self.value(hidden_states))
-
-        query_layer = self.transpose_for_scores(mixed_query_layer)
-
-        past_key_value = (key_layer, value_layer)
-
-        # Take the dot product between "query" and "key" to get the raw attention scores.
-        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
-
-        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
-            seq_length = hidden_states.size()[1]
-            position_ids_l = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(-1, 1)
-            position_ids_r = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(1, -1)
-            distance = position_ids_l - position_ids_r
-            positional_embedding = self.distance_embedding(distance + self.max_position_embeddings - 1)
-            positional_embedding = positional_embedding.to(dtype=query_layer.dtype)  # fp16 compatibility
-
-            if self.position_embedding_type == "relative_key":
-                relative_position_scores = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
-                attention_scores = attention_scores + relative_position_scores
-            elif self.position_embedding_type == "relative_key_query":
-                relative_position_scores_query = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
-                relative_position_scores_key = torch.einsum("bhrd,lrd->bhlr", key_layer, positional_embedding)
-                attention_scores = attention_scores + relative_position_scores_query + relative_position_scores_key
-
-        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
-        if attention_mask is not None:
-            # Apply the attention mask is (precomputed for all layers in BertModel forward() function)
-            attention_scores = attention_scores + attention_mask
-
-        # Normalize the attention scores to probabilities.
-        attention_probs = nn.Softmax(dim=-1)(attention_scores)
-        
-        if is_cross_attention and self.save_attention:
-            self.save_attention_map(attention_probs)
-            attention_probs.register_hook(self.save_attn_gradients)         
-
-        # This is actually dropping out entire tokens to attend to, which might
-        # seem a bit unusual, but is taken from the original Transformer paper.
-        attention_probs_dropped = self.dropout(attention_probs)
-
-        # Mask heads if we want to
-        if head_mask is not None:
-            attention_probs_dropped = attention_probs_dropped * head_mask
-
-        context_layer = torch.matmul(attention_probs_dropped, value_layer)
-
-        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
-        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
-        context_layer = context_layer.view(*new_context_layer_shape)
-
-        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
-
-        outputs = outputs + (past_key_value,)
-        return outputs
-
-
-class BertSelfOutput(nn.Module):
-    def __init__(self, config, twin=False, merge=False):     
-        super().__init__()
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)        
-        if twin:
-            self.dense0 = nn.Linear(config.hidden_size, config.hidden_size)
-            self.dense1 = nn.Linear(config.hidden_size, config.hidden_size)         
-        else:
-            self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        if merge:
-            self.act =  ACT2FN[config.hidden_act]
-            self.merge_layer = nn.Linear(config.hidden_size * 2, config.hidden_size)
-            self.merge = True
-        else:
-            self.merge = False
-
-    def forward(self, hidden_states, input_tensor):
-        if type(hidden_states) == list:
-            hidden_states0 = self.dense0(hidden_states[0])
-            hidden_states1 = self.dense1(hidden_states[1])        
-            if self.merge:  
-                #hidden_states = self.merge_layer(self.act(torch.cat([hidden_states0,hidden_states1],dim=-1)))
-                hidden_states = self.merge_layer(torch.cat([hidden_states0,hidden_states1],dim=-1))
-            else:
-                hidden_states = (hidden_states0+hidden_states1)/2
-        else:    
-            hidden_states = self.dense(hidden_states)
-        hidden_states = self.dropout(hidden_states)
-        hidden_states = self.LayerNorm(hidden_states + input_tensor)
-        return hidden_states
-
-
-class BertAttention(nn.Module):
-    def __init__(self, config, is_cross_attention=False, layer_num=-1):
-        super().__init__()
-        if is_cross_attention:
-            self.self0 = BertSelfAttention(config, is_cross_attention)
-            self.self1 = BertSelfAttention(config, is_cross_attention)
-        else:    
-            self.self = BertSelfAttention(config, is_cross_attention)
-        self.output = BertSelfOutput(config, twin=is_cross_attention, merge=(is_cross_attention and layer_num>=6))
-        self.pruned_heads = set()
-
-    def prune_heads(self, heads):
-        if len(heads) == 0:
-            return
-        heads, index = find_pruneable_heads_and_indices(
-            heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
-        )
-
-        # Prune linear layers
-        self.self.query = prune_linear_layer(self.self.query, index)
-        self.self.key = prune_linear_layer(self.self.key, index)
-        self.self.value = prune_linear_layer(self.self.value, index)
-        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
-
-        # Update hyper params and store pruned heads
-        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
-        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
-        self.pruned_heads = self.pruned_heads.union(heads)
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_value=None,
-        output_attentions=False,
-    ):        
-        if type(encoder_hidden_states)==list:   
-            self_outputs0 = self.self0(
-                hidden_states,
-                attention_mask,
-                head_mask,
-                encoder_hidden_states[0],
-                encoder_attention_mask[0],
-                past_key_value,
-                output_attentions,
-            )
-            self_outputs1 = self.self1(
-                hidden_states,
-                attention_mask,
-                head_mask,
-                encoder_hidden_states[1],
-                encoder_attention_mask[1],
-                past_key_value,
-                output_attentions,
-            )                        
-            attention_output = self.output([self_outputs0[0],self_outputs1[0]], hidden_states)
-    
-            outputs = (attention_output,) + self_outputs0[1:]  # add attentions if we output them
-        else:        
-            self_outputs = self.self(
-                hidden_states,
-                attention_mask,
-                head_mask,
-                encoder_hidden_states,
-                encoder_attention_mask,
-                past_key_value,
-                output_attentions,
-            )
-            attention_output = self.output(self_outputs[0], hidden_states)
-            outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
-        return outputs
-
-
-class BertIntermediate(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
-        if isinstance(config.hidden_act, str):
-            self.intermediate_act_fn = ACT2FN[config.hidden_act]
-        else:
-            self.intermediate_act_fn = config.hidden_act
-
-    def forward(self, hidden_states):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.intermediate_act_fn(hidden_states)
-        return hidden_states
-
-
-class BertOutput(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
-    def forward(self, hidden_states, input_tensor):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.dropout(hidden_states)
-        hidden_states = self.LayerNorm(hidden_states + input_tensor)
-        return hidden_states
-
-
-class BertLayer(nn.Module):
-    def __init__(self, config, layer_num):
-        super().__init__()
-        self.config = config
-        self.chunk_size_feed_forward = config.chunk_size_feed_forward
-        self.seq_len_dim = 1
-        self.attention = BertAttention(config)      
-        self.layer_num = layer_num          
-        if self.config.add_cross_attention:
-            self.crossattention = BertAttention(config, is_cross_attention=self.config.add_cross_attention, layer_num=layer_num)
-        self.intermediate = BertIntermediate(config)
-        self.output = BertOutput(config)
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_value=None,
-        output_attentions=False,
-        mode=None,
-    ):
-        # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
-        self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None
-        self_attention_outputs = self.attention(
-            hidden_states,
-            attention_mask,
-            head_mask,
-            output_attentions=output_attentions,
-            past_key_value=self_attn_past_key_value,
-        )
-        attention_output = self_attention_outputs[0]
-
-        outputs = self_attention_outputs[1:-1]
-        present_key_value = self_attention_outputs[-1]
-
-        if mode=='multimodal':
-            assert encoder_hidden_states is not None, "encoder_hidden_states must be given for cross-attention layers"
-            cross_attention_outputs = self.crossattention(
-                attention_output,
-                attention_mask,
-                head_mask,
-                encoder_hidden_states,
-                encoder_attention_mask,
-                output_attentions=output_attentions,
-            )
-            attention_output = cross_attention_outputs[0]
-            outputs = outputs + cross_attention_outputs[1:-1]  # add cross attentions if we output attention weights                               
-        layer_output = apply_chunking_to_forward(
-            self.feed_forward_chunk, self.chunk_size_feed_forward, self.seq_len_dim, attention_output
-        )
-        outputs = (layer_output,) + outputs
-
-        outputs = outputs + (present_key_value,)
-
-        return outputs
-
-    def feed_forward_chunk(self, attention_output):
-        intermediate_output = self.intermediate(attention_output)
-        layer_output = self.output(intermediate_output, attention_output)
-        return layer_output
-
-
-class BertEncoder(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.config = config
-        self.layer = nn.ModuleList([BertLayer(config,i) for i in range(config.num_hidden_layers)])
-        self.gradient_checkpointing = False
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_values=None,
-        use_cache=None,
-        output_attentions=False,
-        output_hidden_states=False,
-        return_dict=True,
-        mode='multimodal',
-    ):
-        all_hidden_states = () if output_hidden_states else None
-        all_self_attentions = () if output_attentions else None
-        all_cross_attentions = () if output_attentions and self.config.add_cross_attention else None
-
-        next_decoder_cache = () if use_cache else None
-               
-        for i in range(self.config.num_hidden_layers):
-            layer_module = self.layer[i]
-            if output_hidden_states:
-                all_hidden_states = all_hidden_states + (hidden_states,)
-
-            layer_head_mask = head_mask[i] if head_mask is not None else None
-            past_key_value = past_key_values[i] if past_key_values is not None else None
-
-            if self.gradient_checkpointing and self.training:
-
-                if use_cache:
-                    logger.warn(
-                        "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
-                    )
-                    use_cache = False
-
-                def create_custom_forward(module):
-                    def custom_forward(*inputs):
-                        return module(*inputs, past_key_value, output_attentions)
-
-                    return custom_forward
-
-                layer_outputs = torch.utils.checkpoint.checkpoint(
-                    create_custom_forward(layer_module),
-                    hidden_states,
-                    attention_mask,
-                    layer_head_mask,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                    mode=mode,
-                )
-            else:
-                layer_outputs = layer_module(
-                    hidden_states,
-                    attention_mask,
-                    layer_head_mask,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                    past_key_value,
-                    output_attentions,
-                    mode=mode,
-                )
-
-            hidden_states = layer_outputs[0]
-            if use_cache:
-                next_decoder_cache += (layer_outputs[-1],)
-            if output_attentions:
-                all_self_attentions = all_self_attentions + (layer_outputs[1],)
-
-        if output_hidden_states:
-            all_hidden_states = all_hidden_states + (hidden_states,)
-
-        if not return_dict:
-            return tuple(
-                v
-                for v in [
-                    hidden_states,
-                    next_decoder_cache,
-                    all_hidden_states,
-                    all_self_attentions,
-                    all_cross_attentions,
-                ]
-                if v is not None
-            )
-        return BaseModelOutputWithPastAndCrossAttentions(
-            last_hidden_state=hidden_states,
-            past_key_values=next_decoder_cache,
-            hidden_states=all_hidden_states,
-            attentions=all_self_attentions,
-            cross_attentions=all_cross_attentions,
-        )
-
-
-class BertPooler(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        self.activation = nn.Tanh()
-
-    def forward(self, hidden_states):
-        # We "pool" the model by simply taking the hidden state corresponding
-        # to the first token.
-        first_token_tensor = hidden_states[:, 0]
-        pooled_output = self.dense(first_token_tensor)
-        pooled_output = self.activation(pooled_output)
-        return pooled_output
-
-
-class BertPredictionHeadTransform(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        if isinstance(config.hidden_act, str):
-            self.transform_act_fn = ACT2FN[config.hidden_act]
-        else:
-            self.transform_act_fn = config.hidden_act
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-
-    def forward(self, hidden_states):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.transform_act_fn(hidden_states)
-        hidden_states = self.LayerNorm(hidden_states)
-        return hidden_states
-
-
-class BertLMPredictionHead(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.transform = BertPredictionHeadTransform(config)
-
-        # The output weights are the same as the input embeddings, but there is
-        # an output-only bias for each token.
-        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
-
-        self.bias = nn.Parameter(torch.zeros(config.vocab_size))
-
-        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
-        self.decoder.bias = self.bias
-
-    def forward(self, hidden_states):
-        hidden_states = self.transform(hidden_states)
-        hidden_states = self.decoder(hidden_states)
-        return hidden_states
-
-
-class BertOnlyMLMHead(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.predictions = BertLMPredictionHead(config)
-
-    def forward(self, sequence_output):
-        prediction_scores = self.predictions(sequence_output)
-        return prediction_scores
-
-
-class BertPreTrainedModel(PreTrainedModel):
-    """
-    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
-    models.
-    """
-
-    config_class = BertConfig
-    base_model_prefix = "bert"
-    _keys_to_ignore_on_load_missing = [r"position_ids"]
-
-    def _init_weights(self, module):
-        """ Initialize the weights """
-        if isinstance(module, (nn.Linear, nn.Embedding)):
-            # Slightly different from the TF version which uses truncated_normal for initialization
-            # cf https://github.com/pytorch/pytorch/pull/5617
-            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
-        elif isinstance(module, nn.LayerNorm):
-            module.bias.data.zero_()
-            module.weight.data.fill_(1.0)
-        if isinstance(module, nn.Linear) and module.bias is not None:
-            module.bias.data.zero_()
-
-
-class BertModel(BertPreTrainedModel):
-    """
-    The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of
-    cross-attention is added between the self-attention layers, following the architecture described in `Attention is
-    all you need <https://arxiv.org/abs/1706.03762>`__ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit,
-    Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
-    argument and :obj:`add_cross_attention` set to :obj:`True`; an :obj:`encoder_hidden_states` is then expected as an
-    input to the forward pass.
-    """
-
-    def __init__(self, config, add_pooling_layer=True):
-        super().__init__(config)
-        self.config = config
-
-        self.embeddings = BertEmbeddings(config)
-        
-        self.encoder = BertEncoder(config)
-
-        self.pooler = BertPooler(config) if add_pooling_layer else None
-
-        self.init_weights()
- 
-
-    def get_input_embeddings(self):
-        return self.embeddings.word_embeddings
-
-    def set_input_embeddings(self, value):
-        self.embeddings.word_embeddings = value
-
-    def _prune_heads(self, heads_to_prune):
-        """
-        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
-        class PreTrainedModel
-        """
-        for layer, heads in heads_to_prune.items():
-            self.encoder.layer[layer].attention.prune_heads(heads)
-
-    
-    def get_extended_attention_mask(self, attention_mask: Tensor, input_shape: Tuple[int], device: device, is_decoder: bool) -> Tensor:
-        """
-        Makes broadcastable attention and causal masks so that future and masked tokens are ignored.
-
-        Arguments:
-            attention_mask (:obj:`torch.Tensor`):
-                Mask with ones indicating tokens to attend to, zeros for tokens to ignore.
-            input_shape (:obj:`Tuple[int]`):
-                The shape of the input to the model.
-            device: (:obj:`torch.device`):
-                The device of the input to the model.
-
-        Returns:
-            :obj:`torch.Tensor` The extended attention mask, with a the same dtype as :obj:`attention_mask.dtype`.
-        """
-        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
-        # ourselves in which case we just need to make it broadcastable to all heads.
-        if attention_mask.dim() == 3:
-            extended_attention_mask = attention_mask[:, None, :, :]
-        elif attention_mask.dim() == 2:
-            # Provided a padding mask of dimensions [batch_size, seq_length]
-            # - if the model is a decoder, apply a causal mask in addition to the padding mask
-            # - if the model is an encoder, make the mask broadcastable to [batch_size, num_heads, seq_length, seq_length]
-            if is_decoder:
-                batch_size, seq_length = input_shape
-
-                seq_ids = torch.arange(seq_length, device=device)
-                causal_mask = seq_ids[None, None, :].repeat(batch_size, seq_length, 1) <= seq_ids[None, :, None]
-                # in case past_key_values are used we need to add a prefix ones mask to the causal mask
-                # causal and attention masks must have same type with pytorch version < 1.3
-                causal_mask = causal_mask.to(attention_mask.dtype)
-   
-                if causal_mask.shape[1] < attention_mask.shape[1]:
-                    prefix_seq_len = attention_mask.shape[1] - causal_mask.shape[1]
-                    causal_mask = torch.cat(
-                        [
-                            torch.ones((batch_size, seq_length, prefix_seq_len), device=device, dtype=causal_mask.dtype),
-                            causal_mask,
-                        ],
-                        axis=-1,
-                    )                     
-
-                extended_attention_mask = causal_mask[:, None, :, :] * attention_mask[:, None, None, :]
-            else:
-                extended_attention_mask = attention_mask[:, None, None, :]
-        else:
-            raise ValueError(
-                "Wrong shape for input_ids (shape {}) or attention_mask (shape {})".format(
-                    input_shape, attention_mask.shape
-                )
-            )
-
-        # Since attention_mask is 1.0 for positions we want to attend and 0.0 for
-        # masked positions, this operation will create a tensor which is 0.0 for
-        # positions we want to attend and -10000.0 for masked positions.
-        # Since we are adding it to the raw scores before the softmax, this is
-        # effectively the same as removing these entirely.
-        extended_attention_mask = extended_attention_mask.to(dtype=self.dtype)  # fp16 compatibility
-        extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0
-        return extended_attention_mask
-    
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        position_ids=None,
-        head_mask=None,
-        inputs_embeds=None,
-        encoder_embeds=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_values=None,
-        use_cache=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-        is_decoder=False,
-        mode='multimodal',
-    ):
-        r"""
-        encoder_hidden_states  (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):
-            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
-            the model is configured as a decoder.
-        encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
-            Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
-            the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``:
-            - 1 for tokens that are **not masked**,
-            - 0 for tokens that are **masked**.
-        past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
-            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
-            If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids`
-            (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)`
-            instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`.
-        use_cache (:obj:`bool`, `optional`):
-            If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up
-            decoding (see :obj:`past_key_values`).
-        """
-        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
-        output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
-        )
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        if is_decoder:
-            use_cache = use_cache if use_cache is not None else self.config.use_cache
-        else:
-            use_cache = False
-
-        if input_ids is not None and inputs_embeds is not None:
-            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
-        elif input_ids is not None:
-            input_shape = input_ids.size()
-            batch_size, seq_length = input_shape
-            device = input_ids.device
-        elif inputs_embeds is not None:
-            input_shape = inputs_embeds.size()[:-1]
-            batch_size, seq_length = input_shape
-            device = inputs_embeds.device
-        elif encoder_embeds is not None:    
-            input_shape = encoder_embeds.size()[:-1]
-            batch_size, seq_length = input_shape 
-            device = encoder_embeds.device
-        else:
-            raise ValueError("You have to specify either input_ids or inputs_embeds or encoder_embeds")
-
-        # past_key_values_length
-        past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
-
-        if attention_mask is None:
-            attention_mask = torch.ones(((batch_size, seq_length + past_key_values_length)), device=device)
-            
-        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
-        # ourselves in which case we just need to make it broadcastable to all heads.
-        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(attention_mask, input_shape, 
-                                                                                 device, is_decoder)
-
-        # If a 2D or 3D attention mask is provided for the cross-attention
-        # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
-        if encoder_hidden_states is not None:
-            if type(encoder_hidden_states) == list:
-                encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states[0].size()
-            else:
-                encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
-            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
-            
-            if type(encoder_attention_mask) == list:
-                encoder_extended_attention_mask = [self.invert_attention_mask(mask) for mask in encoder_attention_mask]
-            elif encoder_attention_mask is None:
-                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
-                encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
-            else:    
-                encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
-        else:
-            encoder_extended_attention_mask = None
-
-        # Prepare head mask if needed
-        # 1.0 in head_mask indicate we keep the head
-        # attention_probs has shape bsz x n_heads x N x N
-        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
-        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
-        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
-        
-        if encoder_embeds is None:
-            embedding_output = self.embeddings(
-                input_ids=input_ids,
-                position_ids=position_ids,
-                inputs_embeds=inputs_embeds,
-                past_key_values_length=past_key_values_length,
-            )
-        else:
-            embedding_output = encoder_embeds
-            
-        encoder_outputs = self.encoder(
-            embedding_output,
-            attention_mask=extended_attention_mask,
-            head_mask=head_mask,
-            encoder_hidden_states=encoder_hidden_states,
-            encoder_attention_mask=encoder_extended_attention_mask,
-            past_key_values=past_key_values,
-            use_cache=use_cache,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-            mode=mode,
-        )
-        sequence_output = encoder_outputs[0]
-        pooled_output = self.pooler(sequence_output) if self.pooler is not None else None
-
-        if not return_dict:
-            return (sequence_output, pooled_output) + encoder_outputs[1:]
-
-        return BaseModelOutputWithPoolingAndCrossAttentions(
-            last_hidden_state=sequence_output,
-            pooler_output=pooled_output,
-            past_key_values=encoder_outputs.past_key_values,
-            hidden_states=encoder_outputs.hidden_states,
-            attentions=encoder_outputs.attentions,
-            cross_attentions=encoder_outputs.cross_attentions,
-        )
-
diff --git a/spaces/sajithlal65/emilianJR-epiCRealism/app.py b/spaces/sajithlal65/emilianJR-epiCRealism/app.py
deleted file mode 100644
index ced3fb3619ed5129db294981eb60aacba1d8f114..0000000000000000000000000000000000000000
--- a/spaces/sajithlal65/emilianJR-epiCRealism/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/emilianJR/epiCRealism").launch()
\ No newline at end of file
diff --git a/spaces/samarthagarwal23/Scotch_recommendation/app.py b/spaces/samarthagarwal23/Scotch_recommendation/app.py
deleted file mode 100644
index ad5f50923de260eefc6de3d12053f4509266870d..0000000000000000000000000000000000000000
--- a/spaces/samarthagarwal23/Scotch_recommendation/app.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import gradio as gr
-import pandas as pd
-import pickle
-from sentence_transformers import SentenceTransformer, util
-import re
-
-mdl_name = 'sentence-transformers/all-distilroberta-v1'
-model = SentenceTransformer(mdl_name)
-
-embedding_cache_path = "scotch_embd_distilroberta.pkl"
-with open(embedding_cache_path, "rb") as fIn:
-    cache_data = pickle.load(fIn)
-
-embedding_table = cache_data["embeddings"]
-reviews = cache_data["data"]
-reviews['price'] = reviews.price.apply(lambda x: re.findall("\d+", x.replace(",","").replace(".00","").replace("$",""))[0]).astype('int')
-
-def user_query_recommend(query, price_rng):
-    # Embed user query
-    embedding = model.encode(query)
-
-    # Calculate similarity with all reviews
-    sim_scores = util.cos_sim(embedding, embedding_table)
-    #print(sim_scores.shape)
-
-    # Recommend
-    recommendations = reviews.copy()
-    recommendations['sim'] = sim_scores.T
-    if price_rng == "$0-$70":
-        min_p, max_p = 0, 70
-    if price_rng == "$70-$150":
-        min_p, max_p = 70, 150
-    if price_rng == "$150+":
-        min_p, max_p = 150, 10000
-        
-    op=recommendations\
-            .groupby("name")\
-            .sim.nlargest(2)\
-            .reset_index()\
-            [["name","sim"]]
-
-    op = pd.merge(op, 
-                  recommendations[['name', 'category', 'price', 'description','description_sent','sim']],
-                  how="left",on=["name",'sim'])
-
-    op = op.loc[(op.price >= min_p) & (op.price <= max_p),
-                ['name', 'category', 'price', 'description', 'description_sent','sim']].sort_values('sim',ascending=False)\
-            .groupby(['name', 'category', 'price', 'description'])\
-            .agg({"description_sent": lambda x: " ".join(x),
-                  "sim":['max']})\
-            .reset_index()\
-            .set_axis(['name', 'category', 'price', 'description', 'description_sent','sim'],axis="columns")
-
-     #op = op.loc[(op.price >= min_p) & (op.price <= max_p), ['name', 'price', 'description_sent']]
-
-    return op[['name', 'price', 'description_sent']].reset_index(drop=True).head(6)
-    
-interface = gr.Interface(
-    user_query_recommend, 
-    inputs=[gr.inputs.Textbox(lines=5, label = "enter flavour profile"),
-            gr.inputs.Radio(choices = ["$0-$70", "$70-$150", "$150+"], default="$0-$70", type="value", label='Price range')],
-    outputs=gr.outputs.Dataframe(max_rows=3, overflow_row_behaviour="paginate", type="pandas", label="Scotch recommendations"),
-    title = "Scotch Recommendation",
-    description = "Looking for scotch recommendations and have some flavours in mind? \nGet recommendations at a preferred price range using semantic search :) ",
-    examples=[["very sweet with lemons and oranges and marmalades", "$0-$70"], 
-              ["smoky peaty and wood fire","$70-$150"],
-              ["salty and spicy with exotic fruits", "$150+"], 
-              ["fragrant nose with chocolate, custard, toffee, pudding and caramel", "$70-$150"], 
-              ],
-    theme="grass",
-)
-
-interface.launch(
-    enable_queue=True,
-    #cache_examples=True,
-)
\ No newline at end of file
diff --git a/spaces/sayakpaul/sots-indoor-dehazing-maxim/maxim/layers.py b/spaces/sayakpaul/sots-indoor-dehazing-maxim/maxim/layers.py
deleted file mode 100644
index e9fd870e335674cf6bd040bf27c9194d53dc4409..0000000000000000000000000000000000000000
--- a/spaces/sayakpaul/sots-indoor-dehazing-maxim/maxim/layers.py
+++ /dev/null
@@ -1,101 +0,0 @@
-import einops
-import tensorflow as tf
-from tensorflow.experimental import numpy as tnp
-from tensorflow.keras import backend as K
-from tensorflow.keras import layers
-
-
-@tf.keras.utils.register_keras_serializable("maxim")
-class BlockImages(layers.Layer):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    def call(self, x, patch_size):
-        bs, h, w, num_channels = (
-            K.int_shape(x)[0],
-            K.int_shape(x)[1],
-            K.int_shape(x)[2],
-            K.int_shape(x)[3],
-        )
-
-        grid_height, grid_width = h // patch_size[0], w // patch_size[1]
-
-        x = einops.rearrange(
-            x,
-            "n (gh fh) (gw fw) c -> n (gh gw) (fh fw) c",
-            gh=grid_height,
-            gw=grid_width,
-            fh=patch_size[0],
-            fw=patch_size[1],
-        )
-
-        return x
-
-    def get_config(self):
-        config = super().get_config().copy()
-        return config
-
-
-@tf.keras.utils.register_keras_serializable("maxim")
-class UnblockImages(layers.Layer):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    def call(self, x, grid_size, patch_size):
-        x = einops.rearrange(
-            x,
-            "n (gh gw) (fh fw) c -> n (gh fh) (gw fw) c",
-            gh=grid_size[0],
-            gw=grid_size[1],
-            fh=patch_size[0],
-            fw=patch_size[1],
-        )
-
-        return x
-
-    def get_config(self):
-        config = super().get_config().copy()
-        return config
-
-
-@tf.keras.utils.register_keras_serializable("maxim")
-class SwapAxes(layers.Layer):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    def call(self, x, axis_one, axis_two):
-        return tnp.swapaxes(x, axis_one, axis_two)
-
-    def get_config(self):
-        config = super().get_config().copy()
-        return config
-
-
-@tf.keras.utils.register_keras_serializable("maxim")
-class Resizing(layers.Layer):
-    def __init__(self, height, width, antialias=True, method="bilinear", **kwargs):
-        super().__init__(**kwargs)
-        self.height = height
-        self.width = width
-        self.antialias = antialias
-        self.method = method
-
-    def call(self, x):
-        return tf.image.resize(
-            x,
-            size=(self.height, self.width),
-            antialias=self.antialias,
-            method=self.method,
-        )
-
-    def get_config(self):
-        config = super().get_config().copy()
-        config.update(
-            {
-                "height": self.height,
-                "width": self.width,
-                "antialias": self.antialias,
-                "method": self.method,
-            }
-        )
-        return config
diff --git a/spaces/scedlatioru/img-to-music/example/Imagenomic Noiseware Professional Cs6 Keygenl ((INSTALL)).md b/spaces/scedlatioru/img-to-music/example/Imagenomic Noiseware Professional Cs6 Keygenl ((INSTALL)).md
deleted file mode 100644
index a7ee25e35112ef002ce8e43c45b8e0d4afad322a..0000000000000000000000000000000000000000
--- a/spaces/scedlatioru/img-to-music/example/Imagenomic Noiseware Professional Cs6 Keygenl ((INSTALL)).md	
+++ /dev/null
@@ -1,39 +0,0 @@
-
-<h1>How to Use Imagenomic Noiseware Professional Cs6 Keygenl to Enhance Your Photos</h1>
-<p>If you are looking for a way to reduce noise and improve the quality of your photos, you might want to try Imagenomic Noiseware Professional Cs6 Keygenl. This is a powerful plugin that works with Adobe Photoshop CS6 and other compatible software. It can help you remove unwanted noise, grain, and artifacts from your images, while preserving the details and sharpness.</p>
-<p>In this article, we will show you how to use Imagenomic Noiseware Professional Cs6 Keygenl to enhance your photos. We will also provide you with a link to download the plugin and a keygen to activate it.</p>
-<h2>Imagenomic Noiseware Professional Cs6 Keygenl</h2><br /><p><b><b>Download File</b> &#10038; <a href="https://gohhs.com/2uEzlW">https://gohhs.com/2uEzlW</a></b></p><br /><br />
-<h2>What is Imagenomic Noiseware Professional Cs6 Keygenl?</h2>
-<p>Imagenomic Noiseware Professional Cs6 Keygenl is a plugin that allows you to apply noise reduction and sharpening effects to your photos. It uses an advanced algorithm that analyzes the image and detects the noise patterns. It then applies a customized filter that removes the noise without affecting the image quality.</p>
-<p>Imagenomic Noiseware Professional Cs6 Keygenl has several features that make it stand out from other noise reduction plugins. Some of these features are:</p>
-<p></p>
-<ul>
-<li>It has a user-friendly interface that lets you adjust the settings according to your preferences.</li>
-<li>It has a preview window that shows you the before and after effects of the noise reduction.</li>
-<li>It has a batch processing mode that lets you apply the same settings to multiple images at once.</li>
-<li>It has a smart profile feature that automatically selects the best settings for each image based on its characteristics.</li>
-<li>It has a toolset feature that lets you fine-tune the noise reduction and sharpening effects for specific areas of the image.</li>
-</ul>
-<p>Imagenomic Noiseware Professional Cs6 Keygenl is compatible with Adobe Photoshop CS6 and other software that supports Photoshop plugins. You can use it with Windows or Mac operating systems.</p>
-<h2>How to Download and Install Imagenomic Noiseware Professional Cs6 Keygenl?</h2>
-<p>To download and install Imagenomic Noiseware Professional Cs6 Keygenl, you need to follow these steps:</p>
-<ol>
-<li>Go to this link: <a href="https://imagenomic.com/Products/Noiseware">https://imagenomic.com/Products/Noiseware</a> and click on the "Download" button.</li>
-<li>Select your operating system and click on the "Download" button again.</li>
-<li>Save the file on your computer and unzip it.</li>
-<li>Run the installer and follow the instructions on the screen.</li>
-<li>Copy the plugin file (Noiseware.8bf) from the folder where you installed it and paste it in the folder where your Photoshop plugins are located. For example, if you have Photoshop CS6 installed on Windows, you might find the plugins folder here: C:\Program Files\Adobe\Adobe Photoshop CS6\Plug-ins</li>
-<li>Run Photoshop and open an image that you want to edit.</li>
-<li>Go to Filter > Imagenomic > Noiseware 5... to launch the plugin.</li>
-</ol>
-<h2>How to Activate Imagenomic Noiseware Professional Cs6 Keygenl?</h2>
-<p>To activate Imagenomic Noiseware Professional Cs6 Keygenl, you need to use a keygen that generates a valid license code for you. You can download the keygen from this link: <a href="https://bit.ly/3n0wZ0f">https://bit.ly/3n0wZ0f</a></p>
-<p>To use the keygen, you need to follow these steps:</p>
-<ol>
-<li>Run the keygen and click on the "Generate" button.</li>
-<li>Copy the license code that appears on the screen.</li>
-<li>Go back to Photoshop and open the plugin window.</li>
-<li>Click on the "About" button at the bottom right corner of the window.</li>
-<li>Paste the license code in the box that appears and click on "</p> d5da3c52bf<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/sczhou/ProPainter/web-demos/hugging_face/tracker/model/transformer/object_transformer.py b/spaces/sczhou/ProPainter/web-demos/hugging_face/tracker/model/transformer/object_transformer.py
deleted file mode 100644
index 71f0830247495df161f6126dd40ea9ff7f30b9f2..0000000000000000000000000000000000000000
--- a/spaces/sczhou/ProPainter/web-demos/hugging_face/tracker/model/transformer/object_transformer.py
+++ /dev/null
@@ -1,205 +0,0 @@
-from typing import Dict, Optional
-from omegaconf import DictConfig
-
-import torch
-import torch.nn as nn
-from tracker.model.group_modules import GConv2d
-from tracker.utils.tensor_utils import aggregate
-from tracker.model.transformer.positional_encoding import PositionalEncoding
-from tracker.model.transformer.transformer_layers import *
-
-
-class QueryTransformerBlock(nn.Module):
-    def __init__(self, model_cfg: DictConfig):
-        super().__init__()
-
-        this_cfg = model_cfg.object_transformer
-        self.embed_dim = this_cfg.embed_dim
-        self.num_heads = this_cfg.num_heads
-        self.num_queries = this_cfg.num_queries
-        self.ff_dim = this_cfg.ff_dim
-
-        self.read_from_pixel = CrossAttention(self.embed_dim,
-                                              self.num_heads,
-                                              add_pe_to_qkv=this_cfg.read_from_pixel.add_pe_to_qkv)
-        self.self_attn = SelfAttention(self.embed_dim,
-                                       self.num_heads,
-                                       add_pe_to_qkv=this_cfg.query_self_attention.add_pe_to_qkv)
-        self.ffn = FFN(self.embed_dim, self.ff_dim)
-        self.read_from_query = CrossAttention(self.embed_dim,
-                                              self.num_heads,
-                                              add_pe_to_qkv=this_cfg.read_from_query.add_pe_to_qkv,
-                                              norm=this_cfg.read_from_query.output_norm)
-        self.pixel_ffn = PixelFFN(self.embed_dim)
-
-    def forward(
-            self,
-            x: torch.Tensor,
-            pixel: torch.Tensor,
-            query_pe: torch.Tensor,
-            pixel_pe: torch.Tensor,
-            attn_mask: torch.Tensor,
-            need_weights: bool = False) -> (torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor):
-        # x: (bs*num_objects)*num_queries*embed_dim
-        # pixel: bs*num_objects*C*H*W
-        # query_pe: (bs*num_objects)*num_queries*embed_dim
-        # pixel_pe: (bs*num_objects)*(H*W)*C
-        # attn_mask: (bs*num_objects*num_heads)*num_queries*(H*W)
-
-        # bs*num_objects*C*H*W -> (bs*num_objects)*(H*W)*C
-        pixel_flat = pixel.flatten(3, 4).flatten(0, 1).transpose(1, 2).contiguous()
-        x, q_weights = self.read_from_pixel(x,
-                                            pixel_flat,
-                                            query_pe,
-                                            pixel_pe,
-                                            attn_mask=attn_mask,
-                                            need_weights=need_weights)
-        x = self.self_attn(x, query_pe)
-        x = self.ffn(x)
-
-        pixel_flat, p_weights = self.read_from_query(pixel_flat,
-                                                     x,
-                                                     pixel_pe,
-                                                     query_pe,
-                                                     need_weights=need_weights)
-        pixel = self.pixel_ffn(pixel, pixel_flat)
-
-        if need_weights:
-            bs, num_objects, _, h, w = pixel.shape
-            q_weights = q_weights.view(bs, num_objects, self.num_heads, self.num_queries, h, w)
-            p_weights = p_weights.transpose(2, 3).view(bs, num_objects, self.num_heads,
-                                                       self.num_queries, h, w)
-
-        return x, pixel, q_weights, p_weights
-
-
-class QueryTransformer(nn.Module):
-    def __init__(self, model_cfg: DictConfig):
-        super().__init__()
-
-        this_cfg = model_cfg.object_transformer
-        self.value_dim = model_cfg.value_dim
-        self.embed_dim = this_cfg.embed_dim
-        self.num_heads = this_cfg.num_heads
-        self.num_queries = this_cfg.num_queries
-
-        # query initialization and embedding
-        self.query_init = nn.Embedding(self.num_queries, self.embed_dim)
-        self.query_emb = nn.Embedding(self.num_queries, self.embed_dim)
-
-        # projection from object summaries to query initialization and embedding
-        self.summary_to_query_init = nn.Linear(self.embed_dim, self.embed_dim)
-        self.summary_to_query_emb = nn.Linear(self.embed_dim, self.embed_dim)
-
-        self.pixel_pe_scale = model_cfg.pixel_pe_scale
-        self.pixel_pe_temperature = model_cfg.pixel_pe_temperature
-        self.pixel_init_proj = GConv2d(self.embed_dim, self.embed_dim, kernel_size=1)
-        self.pixel_emb_proj = GConv2d(self.embed_dim, self.embed_dim, kernel_size=1)
-        self.spatial_pe = PositionalEncoding(self.embed_dim,
-                                             scale=self.pixel_pe_scale,
-                                             temperature=self.pixel_pe_temperature,
-                                             channel_last=False,
-                                             transpose_output=True)
-
-        # transformer blocks
-        self.num_blocks = this_cfg.num_blocks
-        self.blocks = nn.ModuleList(
-            QueryTransformerBlock(model_cfg) for _ in range(self.num_blocks))
-        self.mask_pred = nn.ModuleList(
-            nn.Sequential(nn.ReLU(), GConv2d(self.embed_dim, 1, kernel_size=1))
-            for _ in range(self.num_blocks + 1))
-
-        self.act = nn.ReLU(inplace=True)
-
-    def forward(self,
-                pixel: torch.Tensor,
-                obj_summaries: torch.Tensor,
-                selector: Optional[torch.Tensor] = None,
-                need_weights: bool = False) -> (torch.Tensor, Dict[str, torch.Tensor]):
-        # pixel: B*num_objects*embed_dim*H*W
-        # obj_summaries: B*num_objects*T*num_queries*embed_dim
-        T = obj_summaries.shape[2]
-        bs, num_objects, _, H, W = pixel.shape
-
-        # normalize object values
-        # the last channel is the cumulative area of the object
-        obj_summaries = obj_summaries.view(bs * num_objects, T, self.num_queries,
-                                           self.embed_dim + 1)
-        # sum over time
-        # during inference, T=1 as we already did streaming average in memory_manager
-        obj_sums = obj_summaries[:, :, :, :-1].sum(dim=1)
-        obj_area = obj_summaries[:, :, :, -1:].sum(dim=1)
-        obj_values = obj_sums / (obj_area + 1e-4)
-        obj_init = self.summary_to_query_init(obj_values)
-        obj_emb = self.summary_to_query_emb(obj_values)
-
-        # positional embeddings for object queries
-        query = self.query_init.weight.unsqueeze(0).expand(bs * num_objects, -1, -1) + obj_init
-        query_emb = self.query_emb.weight.unsqueeze(0).expand(bs * num_objects, -1, -1) + obj_emb
-
-        # positional embeddings for pixel features
-        pixel_init = self.pixel_init_proj(pixel)
-        pixel_emb = self.pixel_emb_proj(pixel)
-        pixel_pe = self.spatial_pe(pixel.flatten(0, 1))
-        pixel_emb = pixel_emb.flatten(3, 4).flatten(0, 1).transpose(1, 2).contiguous()
-        pixel_pe = pixel_pe.flatten(1, 2) + pixel_emb
-
-        pixel = pixel_init
-
-        # run the transformer
-        aux_features = {'logits': []}
-
-        # first aux output
-        aux_logits = self.mask_pred[0](pixel).squeeze(2)
-        attn_mask = self._get_aux_mask(aux_logits, selector)
-        aux_features['logits'].append(aux_logits)
-        for i in range(self.num_blocks):
-            query, pixel, q_weights, p_weights = self.blocks[i](query,
-                                                                pixel,
-                                                                query_emb,
-                                                                pixel_pe,
-                                                                attn_mask,
-                                                                need_weights=need_weights)
-
-            if self.training or i <= self.num_blocks - 1 or need_weights:
-                aux_logits = self.mask_pred[i + 1](pixel).squeeze(2)
-                attn_mask = self._get_aux_mask(aux_logits, selector)
-                aux_features['logits'].append(aux_logits)
-
-        aux_features['q_weights'] = q_weights  # last layer only
-        aux_features['p_weights'] = p_weights  # last layer only
-
-        if self.training:
-            # no need to save all heads
-            aux_features['attn_mask'] = attn_mask.view(bs, num_objects, self.num_heads,
-                                                       self.num_queries, H, W)[:, :, 0]
-
-        return pixel, aux_features
-
-    def _get_aux_mask(self, logits: torch.Tensor, selector: torch.Tensor) -> torch.Tensor:
-        # logits: batch_size*num_objects*H*W
-        # selector: batch_size*num_objects*1*1
-        # returns a mask of shape (batch_size*num_objects*num_heads)*num_queries*(H*W)
-        # where True means the attention is blocked
-
-        if selector is None:
-            prob = logits.sigmoid()
-        else:
-            prob = logits.sigmoid() * selector
-        logits = aggregate(prob, dim=1)
-
-        is_foreground = (logits[:, 1:] >= logits.max(dim=1, keepdim=True)[0])
-        foreground_mask = is_foreground.bool().flatten(start_dim=2)
-        inv_foreground_mask = ~foreground_mask
-        inv_background_mask = foreground_mask
-
-        aux_foreground_mask = inv_foreground_mask.unsqueeze(2).unsqueeze(2).repeat(
-            1, 1, self.num_heads, self.num_queries // 2, 1).flatten(start_dim=0, end_dim=2)
-        aux_background_mask = inv_background_mask.unsqueeze(2).unsqueeze(2).repeat(
-            1, 1, self.num_heads, self.num_queries // 2, 1).flatten(start_dim=0, end_dim=2)
-
-        aux_mask = torch.cat([aux_foreground_mask, aux_background_mask], dim=1)
-
-        aux_mask[torch.where(aux_mask.sum(-1) == aux_mask.shape[-1])] = False
-
-        return aux_mask
\ No newline at end of file
diff --git a/spaces/segments-tobias/conex/espnet/nets/pytorch_backend/transducer/error_calculator.py b/spaces/segments-tobias/conex/espnet/nets/pytorch_backend/transducer/error_calculator.py
deleted file mode 100644
index 5989f1ea2f4cfd306845bbd27a484c5bdcfffaeb..0000000000000000000000000000000000000000
--- a/spaces/segments-tobias/conex/espnet/nets/pytorch_backend/transducer/error_calculator.py
+++ /dev/null
@@ -1,163 +0,0 @@
-#!/usr/bin/env python3
-# encoding: utf-8
-
-"""CER/WER monitoring for transducer models."""
-
-import editdistance
-
-from espnet.nets.beam_search_transducer import BeamSearchTransducer
-
-
-class ErrorCalculator(object):
-    """Calculate CER and WER for transducer models.
-
-    Args:
-        decoder (torch.nn.Module|TransducerDecoderInterface): decoder module
-        joint_network (torch.nn.Module): joint network module
-        token_list (list): list of tokens
-        sym_space (str): space symbol
-        sym_blank (str): blank symbol
-        report_cer (boolean): compute CER option
-        report_wer (boolean): compute WER option
-
-    """
-
-    def __init__(
-        self,
-        decoder,
-        joint_network,
-        token_list,
-        sym_space,
-        sym_blank,
-        report_cer=False,
-        report_wer=False,
-    ):
-        """Construct an ErrorCalculator object for transducer model."""
-        super().__init__()
-
-        self.beam_search = BeamSearchTransducer(
-            decoder=decoder,
-            joint_network=joint_network,
-            beam_size=1,
-        )
-
-        self.decoder = decoder
-
-        self.token_list = token_list
-        self.space = sym_space
-        self.blank = sym_blank
-
-        self.report_cer = report_cer
-        self.report_wer = report_wer
-
-    def __call__(self, hs_pad, ys_pad):
-        """Calculate sentence-level WER/CER score for transducer models.
-
-        Args:
-            hs_pad (torch.Tensor): batch of padded input sequence (batch, T, D)
-            ys_pad (torch.Tensor): reference (batch, seqlen)
-
-        Returns:
-            (float): sentence-level CER score
-            (float): sentence-level WER score
-
-        """
-        cer, wer = None, None
-
-        batchsize = int(hs_pad.size(0))
-        batch_nbest = []
-
-        hs_pad = hs_pad.to(next(self.decoder.parameters()).device)
-
-        for b in range(batchsize):
-            nbest_hyps = self.beam_search(hs_pad[b])
-            batch_nbest.append(nbest_hyps[-1])
-
-        ys_hat = [nbest_hyp.yseq[1:] for nbest_hyp in batch_nbest]
-
-        seqs_hat, seqs_true = self.convert_to_char(ys_hat, ys_pad.cpu())
-
-        if self.report_cer:
-            cer = self.calculate_cer(seqs_hat, seqs_true)
-
-        if self.report_wer:
-            wer = self.calculate_wer(seqs_hat, seqs_true)
-
-        return cer, wer
-
-    def convert_to_char(self, ys_hat, ys_pad):
-        """Convert index to character.
-
-        Args:
-            ys_hat (torch.Tensor): prediction (batch, seqlen)
-            ys_pad (torch.Tensor): reference (batch, seqlen)
-
-        Returns:
-            (list): token list of prediction
-            (list): token list of reference
-
-        """
-        seqs_hat, seqs_true = [], []
-
-        for i, y_hat in enumerate(ys_hat):
-            y_true = ys_pad[i]
-
-            seq_hat = [self.token_list[int(idx)] for idx in y_hat]
-            seq_true = [self.token_list[int(idx)] for idx in y_true if int(idx) != -1]
-
-            seq_hat_text = "".join(seq_hat).replace(self.space, " ")
-            seq_hat_text = seq_hat_text.replace(self.blank, "")
-            seq_true_text = "".join(seq_true).replace(self.space, " ")
-
-            seqs_hat.append(seq_hat_text)
-            seqs_true.append(seq_true_text)
-
-        return seqs_hat, seqs_true
-
-    def calculate_cer(self, seqs_hat, seqs_true):
-        """Calculate sentence-level CER score for transducer model.
-
-        Args:
-            seqs_hat (torch.Tensor): prediction (batch, seqlen)
-            seqs_true (torch.Tensor): reference (batch, seqlen)
-
-        Returns:
-            (float): average sentence-level CER score
-
-        """
-        char_eds, char_ref_lens = [], []
-
-        for i, seq_hat_text in enumerate(seqs_hat):
-            seq_true_text = seqs_true[i]
-
-            hyp_chars = seq_hat_text.replace(" ", "")
-            ref_chars = seq_true_text.replace(" ", "")
-
-            char_eds.append(editdistance.eval(hyp_chars, ref_chars))
-            char_ref_lens.append(len(ref_chars))
-
-        return float(sum(char_eds)) / sum(char_ref_lens)
-
-    def calculate_wer(self, seqs_hat, seqs_true):
-        """Calculate sentence-level WER score for transducer model.
-
-        Args:
-            seqs_hat (torch.Tensor): prediction (batch, seqlen)
-            seqs_true (torch.Tensor): reference (batch, seqlen)
-
-        Returns:
-            (float): average sentence-level WER score
-
-        """
-        word_eds, word_ref_lens = [], []
-
-        for i, seq_hat_text in enumerate(seqs_hat):
-            seq_true_text = seqs_true[i]
-
-            hyp_words = seq_hat_text.split()
-            ref_words = seq_true_text.split()
-
-            word_eds.append(editdistance.eval(hyp_words, ref_words))
-            word_ref_lens.append(len(ref_words))
-
-        return float(sum(word_eds)) / sum(word_ref_lens)
diff --git a/spaces/segments/panoptic-segment-anything-api/GroundingDINO/groundingdino/util/misc.py b/spaces/segments/panoptic-segment-anything-api/GroundingDINO/groundingdino/util/misc.py
deleted file mode 100644
index d64b84ef24bea0c98e76824feb1903f6bfebe7a5..0000000000000000000000000000000000000000
--- a/spaces/segments/panoptic-segment-anything-api/GroundingDINO/groundingdino/util/misc.py
+++ /dev/null
@@ -1,717 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-"""
-Misc functions, including distributed helpers.
-
-Mostly copy-paste from torchvision references.
-"""
-import colorsys
-import datetime
-import functools
-import io
-import json
-import os
-import pickle
-import subprocess
-import time
-from collections import OrderedDict, defaultdict, deque
-from typing import List, Optional
-
-import numpy as np
-import torch
-import torch.distributed as dist
-
-# needed due to empty tensor bug in pytorch and torchvision 0.5
-import torchvision
-from torch import Tensor
-
-__torchvision_need_compat_flag = float(torchvision.__version__.split(".")[1]) < 7
-if __torchvision_need_compat_flag:
-    from torchvision.ops import _new_empty_tensor
-    from torchvision.ops.misc import _output_size
-
-
-class SmoothedValue(object):
-    """Track a series of values and provide access to smoothed values over a
-    window or the global series average.
-    """
-
-    def __init__(self, window_size=20, fmt=None):
-        if fmt is None:
-            fmt = "{median:.4f} ({global_avg:.4f})"
-        self.deque = deque(maxlen=window_size)
-        self.total = 0.0
-        self.count = 0
-        self.fmt = fmt
-
-    def update(self, value, n=1):
-        self.deque.append(value)
-        self.count += n
-        self.total += value * n
-
-    def synchronize_between_processes(self):
-        """
-        Warning: does not synchronize the deque!
-        """
-        if not is_dist_avail_and_initialized():
-            return
-        t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda")
-        dist.barrier()
-        dist.all_reduce(t)
-        t = t.tolist()
-        self.count = int(t[0])
-        self.total = t[1]
-
-    @property
-    def median(self):
-        d = torch.tensor(list(self.deque))
-        if d.shape[0] == 0:
-            return 0
-        return d.median().item()
-
-    @property
-    def avg(self):
-        d = torch.tensor(list(self.deque), dtype=torch.float32)
-        return d.mean().item()
-
-    @property
-    def global_avg(self):
-        if os.environ.get("SHILONG_AMP", None) == "1":
-            eps = 1e-4
-        else:
-            eps = 1e-6
-        return self.total / (self.count + eps)
-
-    @property
-    def max(self):
-        return max(self.deque)
-
-    @property
-    def value(self):
-        return self.deque[-1]
-
-    def __str__(self):
-        return self.fmt.format(
-            median=self.median,
-            avg=self.avg,
-            global_avg=self.global_avg,
-            max=self.max,
-            value=self.value,
-        )
-
-
-@functools.lru_cache()
-def _get_global_gloo_group():
-    """
-    Return a process group based on gloo backend, containing all the ranks
-    The result is cached.
-    """
-
-    if dist.get_backend() == "nccl":
-        return dist.new_group(backend="gloo")
-
-    return dist.group.WORLD
-
-
-def all_gather_cpu(data):
-    """
-    Run all_gather on arbitrary picklable data (not necessarily tensors)
-    Args:
-        data: any picklable object
-    Returns:
-        list[data]: list of data gathered from each rank
-    """
-
-    world_size = get_world_size()
-    if world_size == 1:
-        return [data]
-
-    cpu_group = _get_global_gloo_group()
-
-    buffer = io.BytesIO()
-    torch.save(data, buffer)
-    data_view = buffer.getbuffer()
-    device = "cuda" if cpu_group is None else "cpu"
-    tensor = torch.ByteTensor(data_view).to(device)
-
-    # obtain Tensor size of each rank
-    local_size = torch.tensor([tensor.numel()], device=device, dtype=torch.long)
-    size_list = [torch.tensor([0], device=device, dtype=torch.long) for _ in range(world_size)]
-    if cpu_group is None:
-        dist.all_gather(size_list, local_size)
-    else:
-        print("gathering on cpu")
-        dist.all_gather(size_list, local_size, group=cpu_group)
-    size_list = [int(size.item()) for size in size_list]
-    max_size = max(size_list)
-    assert isinstance(local_size.item(), int)
-    local_size = int(local_size.item())
-
-    # receiving Tensor from all ranks
-    # we pad the tensor because torch all_gather does not support
-    # gathering tensors of different shapes
-    tensor_list = []
-    for _ in size_list:
-        tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device=device))
-    if local_size != max_size:
-        padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device=device)
-        tensor = torch.cat((tensor, padding), dim=0)
-    if cpu_group is None:
-        dist.all_gather(tensor_list, tensor)
-    else:
-        dist.all_gather(tensor_list, tensor, group=cpu_group)
-
-    data_list = []
-    for size, tensor in zip(size_list, tensor_list):
-        tensor = torch.split(tensor, [size, max_size - size], dim=0)[0]
-        buffer = io.BytesIO(tensor.cpu().numpy())
-        obj = torch.load(buffer)
-        data_list.append(obj)
-
-    return data_list
-
-
-def all_gather(data):
-    """
-    Run all_gather on arbitrary picklable data (not necessarily tensors)
-    Args:
-        data: any picklable object
-    Returns:
-        list[data]: list of data gathered from each rank
-    """
-
-    if os.getenv("CPU_REDUCE") == "1":
-        return all_gather_cpu(data)
-
-    world_size = get_world_size()
-    if world_size == 1:
-        return [data]
-
-    # serialized to a Tensor
-    buffer = pickle.dumps(data)
-    storage = torch.ByteStorage.from_buffer(buffer)
-    tensor = torch.ByteTensor(storage).to("cuda")
-
-    # obtain Tensor size of each rank
-    local_size = torch.tensor([tensor.numel()], device="cuda")
-    size_list = [torch.tensor([0], device="cuda") for _ in range(world_size)]
-    dist.all_gather(size_list, local_size)
-    size_list = [int(size.item()) for size in size_list]
-    max_size = max(size_list)
-
-    # receiving Tensor from all ranks
-    # we pad the tensor because torch all_gather does not support
-    # gathering tensors of different shapes
-    tensor_list = []
-    for _ in size_list:
-        tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device="cuda"))
-    if local_size != max_size:
-        padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device="cuda")
-        tensor = torch.cat((tensor, padding), dim=0)
-    dist.all_gather(tensor_list, tensor)
-
-    data_list = []
-    for size, tensor in zip(size_list, tensor_list):
-        buffer = tensor.cpu().numpy().tobytes()[:size]
-        data_list.append(pickle.loads(buffer))
-
-    return data_list
-
-
-def reduce_dict(input_dict, average=True):
-    """
-    Args:
-        input_dict (dict): all the values will be reduced
-        average (bool): whether to do average or sum
-    Reduce the values in the dictionary from all processes so that all processes
-    have the averaged results. Returns a dict with the same fields as
-    input_dict, after reduction.
-    """
-    world_size = get_world_size()
-    if world_size < 2:
-        return input_dict
-    with torch.no_grad():
-        names = []
-        values = []
-        # sort the keys so that they are consistent across processes
-        for k in sorted(input_dict.keys()):
-            names.append(k)
-            values.append(input_dict[k])
-        values = torch.stack(values, dim=0)
-        dist.all_reduce(values)
-        if average:
-            values /= world_size
-        reduced_dict = {k: v for k, v in zip(names, values)}
-    return reduced_dict
-
-
-class MetricLogger(object):
-    def __init__(self, delimiter="\t"):
-        self.meters = defaultdict(SmoothedValue)
-        self.delimiter = delimiter
-
-    def update(self, **kwargs):
-        for k, v in kwargs.items():
-            if isinstance(v, torch.Tensor):
-                v = v.item()
-            assert isinstance(v, (float, int))
-            self.meters[k].update(v)
-
-    def __getattr__(self, attr):
-        if attr in self.meters:
-            return self.meters[attr]
-        if attr in self.__dict__:
-            return self.__dict__[attr]
-        raise AttributeError("'{}' object has no attribute '{}'".format(type(self).__name__, attr))
-
-    def __str__(self):
-        loss_str = []
-        for name, meter in self.meters.items():
-            # print(name, str(meter))
-            # import ipdb;ipdb.set_trace()
-            if meter.count > 0:
-                loss_str.append("{}: {}".format(name, str(meter)))
-        return self.delimiter.join(loss_str)
-
-    def synchronize_between_processes(self):
-        for meter in self.meters.values():
-            meter.synchronize_between_processes()
-
-    def add_meter(self, name, meter):
-        self.meters[name] = meter
-
-    def log_every(self, iterable, print_freq, header=None, logger=None):
-        if logger is None:
-            print_func = print
-        else:
-            print_func = logger.info
-
-        i = 0
-        if not header:
-            header = ""
-        start_time = time.time()
-        end = time.time()
-        iter_time = SmoothedValue(fmt="{avg:.4f}")
-        data_time = SmoothedValue(fmt="{avg:.4f}")
-        space_fmt = ":" + str(len(str(len(iterable)))) + "d"
-        if torch.cuda.is_available():
-            log_msg = self.delimiter.join(
-                [
-                    header,
-                    "[{0" + space_fmt + "}/{1}]",
-                    "eta: {eta}",
-                    "{meters}",
-                    "time: {time}",
-                    "data: {data}",
-                    "max mem: {memory:.0f}",
-                ]
-            )
-        else:
-            log_msg = self.delimiter.join(
-                [
-                    header,
-                    "[{0" + space_fmt + "}/{1}]",
-                    "eta: {eta}",
-                    "{meters}",
-                    "time: {time}",
-                    "data: {data}",
-                ]
-            )
-        MB = 1024.0 * 1024.0
-        for obj in iterable:
-            data_time.update(time.time() - end)
-            yield obj
-            # import ipdb; ipdb.set_trace()
-            iter_time.update(time.time() - end)
-            if i % print_freq == 0 or i == len(iterable) - 1:
-                eta_seconds = iter_time.global_avg * (len(iterable) - i)
-                eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
-                if torch.cuda.is_available():
-                    print_func(
-                        log_msg.format(
-                            i,
-                            len(iterable),
-                            eta=eta_string,
-                            meters=str(self),
-                            time=str(iter_time),
-                            data=str(data_time),
-                            memory=torch.cuda.max_memory_allocated() / MB,
-                        )
-                    )
-                else:
-                    print_func(
-                        log_msg.format(
-                            i,
-                            len(iterable),
-                            eta=eta_string,
-                            meters=str(self),
-                            time=str(iter_time),
-                            data=str(data_time),
-                        )
-                    )
-            i += 1
-            end = time.time()
-        total_time = time.time() - start_time
-        total_time_str = str(datetime.timedelta(seconds=int(total_time)))
-        print_func(
-            "{} Total time: {} ({:.4f} s / it)".format(
-                header, total_time_str, total_time / len(iterable)
-            )
-        )
-
-
-def get_sha():
-    cwd = os.path.dirname(os.path.abspath(__file__))
-
-    def _run(command):
-        return subprocess.check_output(command, cwd=cwd).decode("ascii").strip()
-
-    sha = "N/A"
-    diff = "clean"
-    branch = "N/A"
-    try:
-        sha = _run(["git", "rev-parse", "HEAD"])
-        subprocess.check_output(["git", "diff"], cwd=cwd)
-        diff = _run(["git", "diff-index", "HEAD"])
-        diff = "has uncommited changes" if diff else "clean"
-        branch = _run(["git", "rev-parse", "--abbrev-ref", "HEAD"])
-    except Exception:
-        pass
-    message = f"sha: {sha}, status: {diff}, branch: {branch}"
-    return message
-
-
-def collate_fn(batch):
-    # import ipdb; ipdb.set_trace()
-    batch = list(zip(*batch))
-    batch[0] = nested_tensor_from_tensor_list(batch[0])
-    return tuple(batch)
-
-
-def _max_by_axis(the_list):
-    # type: (List[List[int]]) -> List[int]
-    maxes = the_list[0]
-    for sublist in the_list[1:]:
-        for index, item in enumerate(sublist):
-            maxes[index] = max(maxes[index], item)
-    return maxes
-
-
-class NestedTensor(object):
-    def __init__(self, tensors, mask: Optional[Tensor]):
-        self.tensors = tensors
-        self.mask = mask
-        if mask == "auto":
-            self.mask = torch.zeros_like(tensors).to(tensors.device)
-            if self.mask.dim() == 3:
-                self.mask = self.mask.sum(0).to(bool)
-            elif self.mask.dim() == 4:
-                self.mask = self.mask.sum(1).to(bool)
-            else:
-                raise ValueError(
-                    "tensors dim must be 3 or 4 but {}({})".format(
-                        self.tensors.dim(), self.tensors.shape
-                    )
-                )
-
-    def imgsize(self):
-        res = []
-        for i in range(self.tensors.shape[0]):
-            mask = self.mask[i]
-            maxH = (~mask).sum(0).max()
-            maxW = (~mask).sum(1).max()
-            res.append(torch.Tensor([maxH, maxW]))
-        return res
-
-    def to(self, device):
-        # type: (Device) -> NestedTensor # noqa
-        cast_tensor = self.tensors.to(device)
-        mask = self.mask
-        if mask is not None:
-            assert mask is not None
-            cast_mask = mask.to(device)
-        else:
-            cast_mask = None
-        return NestedTensor(cast_tensor, cast_mask)
-
-    def to_img_list_single(self, tensor, mask):
-        assert tensor.dim() == 3, "dim of tensor should be 3 but {}".format(tensor.dim())
-        maxH = (~mask).sum(0).max()
-        maxW = (~mask).sum(1).max()
-        img = tensor[:, :maxH, :maxW]
-        return img
-
-    def to_img_list(self):
-        """remove the padding and convert to img list
-
-        Returns:
-            [type]: [description]
-        """
-        if self.tensors.dim() == 3:
-            return self.to_img_list_single(self.tensors, self.mask)
-        else:
-            res = []
-            for i in range(self.tensors.shape[0]):
-                tensor_i = self.tensors[i]
-                mask_i = self.mask[i]
-                res.append(self.to_img_list_single(tensor_i, mask_i))
-            return res
-
-    @property
-    def device(self):
-        return self.tensors.device
-
-    def decompose(self):
-        return self.tensors, self.mask
-
-    def __repr__(self):
-        return str(self.tensors)
-
-    @property
-    def shape(self):
-        return {"tensors.shape": self.tensors.shape, "mask.shape": self.mask.shape}
-
-
-def nested_tensor_from_tensor_list(tensor_list: List[Tensor]):
-    # TODO make this more general
-    if tensor_list[0].ndim == 3:
-        if torchvision._is_tracing():
-            # nested_tensor_from_tensor_list() does not export well to ONNX
-            # call _onnx_nested_tensor_from_tensor_list() instead
-            return _onnx_nested_tensor_from_tensor_list(tensor_list)
-
-        # TODO make it support different-sized images
-        max_size = _max_by_axis([list(img.shape) for img in tensor_list])
-        # min_size = tuple(min(s) for s in zip(*[img.shape for img in tensor_list]))
-        batch_shape = [len(tensor_list)] + max_size
-        b, c, h, w = batch_shape
-        dtype = tensor_list[0].dtype
-        device = tensor_list[0].device
-        tensor = torch.zeros(batch_shape, dtype=dtype, device=device)
-        mask = torch.ones((b, h, w), dtype=torch.bool, device=device)
-        for img, pad_img, m in zip(tensor_list, tensor, mask):
-            pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img)
-            m[: img.shape[1], : img.shape[2]] = False
-    else:
-        raise ValueError("not supported")
-    return NestedTensor(tensor, mask)
-
-
-# _onnx_nested_tensor_from_tensor_list() is an implementation of
-# nested_tensor_from_tensor_list() that is supported by ONNX tracing.
-@torch.jit.unused
-def _onnx_nested_tensor_from_tensor_list(tensor_list: List[Tensor]) -> NestedTensor:
-    max_size = []
-    for i in range(tensor_list[0].dim()):
-        max_size_i = torch.max(
-            torch.stack([img.shape[i] for img in tensor_list]).to(torch.float32)
-        ).to(torch.int64)
-        max_size.append(max_size_i)
-    max_size = tuple(max_size)
-
-    # work around for
-    # pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img)
-    # m[: img.shape[1], :img.shape[2]] = False
-    # which is not yet supported in onnx
-    padded_imgs = []
-    padded_masks = []
-    for img in tensor_list:
-        padding = [(s1 - s2) for s1, s2 in zip(max_size, tuple(img.shape))]
-        padded_img = torch.nn.functional.pad(img, (0, padding[2], 0, padding[1], 0, padding[0]))
-        padded_imgs.append(padded_img)
-
-        m = torch.zeros_like(img[0], dtype=torch.int, device=img.device)
-        padded_mask = torch.nn.functional.pad(m, (0, padding[2], 0, padding[1]), "constant", 1)
-        padded_masks.append(padded_mask.to(torch.bool))
-
-    tensor = torch.stack(padded_imgs)
-    mask = torch.stack(padded_masks)
-
-    return NestedTensor(tensor, mask=mask)
-
-
-def setup_for_distributed(is_master):
-    """
-    This function disables printing when not in master process
-    """
-    import builtins as __builtin__
-
-    builtin_print = __builtin__.print
-
-    def print(*args, **kwargs):
-        force = kwargs.pop("force", False)
-        if is_master or force:
-            builtin_print(*args, **kwargs)
-
-    __builtin__.print = print
-
-
-def is_dist_avail_and_initialized():
-    if not dist.is_available():
-        return False
-    if not dist.is_initialized():
-        return False
-    return True
-
-
-def get_world_size():
-    if not is_dist_avail_and_initialized():
-        return 1
-    return dist.get_world_size()
-
-
-def get_rank():
-    if not is_dist_avail_and_initialized():
-        return 0
-    return dist.get_rank()
-
-
-def is_main_process():
-    return get_rank() == 0
-
-
-def save_on_master(*args, **kwargs):
-    if is_main_process():
-        torch.save(*args, **kwargs)
-
-
-def init_distributed_mode(args):
-    if "WORLD_SIZE" in os.environ and os.environ["WORLD_SIZE"] != "":  # 'RANK' in os.environ and
-        args.rank = int(os.environ["RANK"])
-        args.world_size = int(os.environ["WORLD_SIZE"])
-        args.gpu = args.local_rank = int(os.environ["LOCAL_RANK"])
-
-        # launch by torch.distributed.launch
-        # Single node
-        #   python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 1 --rank 0 ...
-        # Multi nodes
-        #   python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 2 --rank 0 --dist-url 'tcp://IP_OF_NODE0:FREEPORT' ...
-        #   python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 2 --rank 1 --dist-url 'tcp://IP_OF_NODE0:FREEPORT' ...
-        # args.rank = int(os.environ.get('OMPI_COMM_WORLD_RANK'))
-        # local_world_size = int(os.environ['GPU_PER_NODE_COUNT'])
-        # args.world_size = args.world_size * local_world_size
-        # args.gpu = args.local_rank = int(os.environ['LOCAL_RANK'])
-        # args.rank = args.rank * local_world_size + args.local_rank
-        print(
-            "world size: {}, rank: {}, local rank: {}".format(
-                args.world_size, args.rank, args.local_rank
-            )
-        )
-        print(json.dumps(dict(os.environ), indent=2))
-    elif "SLURM_PROCID" in os.environ:
-        args.rank = int(os.environ["SLURM_PROCID"])
-        args.gpu = args.local_rank = int(os.environ["SLURM_LOCALID"])
-        args.world_size = int(os.environ["SLURM_NPROCS"])
-
-        print(
-            "world size: {}, world rank: {}, local rank: {}, device_count: {}".format(
-                args.world_size, args.rank, args.local_rank, torch.cuda.device_count()
-            )
-        )
-    else:
-        print("Not using distributed mode")
-        args.distributed = False
-        args.world_size = 1
-        args.rank = 0
-        args.local_rank = 0
-        return
-
-    print("world_size:{} rank:{} local_rank:{}".format(args.world_size, args.rank, args.local_rank))
-    args.distributed = True
-    torch.cuda.set_device(args.local_rank)
-    args.dist_backend = "nccl"
-    print("| distributed init (rank {}): {}".format(args.rank, args.dist_url), flush=True)
-
-    torch.distributed.init_process_group(
-        backend=args.dist_backend,
-        world_size=args.world_size,
-        rank=args.rank,
-        init_method=args.dist_url,
-    )
-
-    print("Before torch.distributed.barrier()")
-    torch.distributed.barrier()
-    print("End torch.distributed.barrier()")
-    setup_for_distributed(args.rank == 0)
-
-
-@torch.no_grad()
-def accuracy(output, target, topk=(1,)):
-    """Computes the precision@k for the specified values of k"""
-    if target.numel() == 0:
-        return [torch.zeros([], device=output.device)]
-    maxk = max(topk)
-    batch_size = target.size(0)
-
-    _, pred = output.topk(maxk, 1, True, True)
-    pred = pred.t()
-    correct = pred.eq(target.view(1, -1).expand_as(pred))
-
-    res = []
-    for k in topk:
-        correct_k = correct[:k].view(-1).float().sum(0)
-        res.append(correct_k.mul_(100.0 / batch_size))
-    return res
-
-
-@torch.no_grad()
-def accuracy_onehot(pred, gt):
-    """_summary_
-
-    Args:
-        pred (_type_): n, c
-        gt (_type_): n, c
-    """
-    tp = ((pred - gt).abs().sum(-1) < 1e-4).float().sum()
-    acc = tp / gt.shape[0] * 100
-    return acc
-
-
-def interpolate(input, size=None, scale_factor=None, mode="nearest", align_corners=None):
-    # type: (Tensor, Optional[List[int]], Optional[float], str, Optional[bool]) -> Tensor
-    """
-    Equivalent to nn.functional.interpolate, but with support for empty batch sizes.
-    This will eventually be supported natively by PyTorch, and this
-    class can go away.
-    """
-    if __torchvision_need_compat_flag < 0.7:
-        if input.numel() > 0:
-            return torch.nn.functional.interpolate(input, size, scale_factor, mode, align_corners)
-
-        output_shape = _output_size(2, input, size, scale_factor)
-        output_shape = list(input.shape[:-2]) + list(output_shape)
-        return _new_empty_tensor(input, output_shape)
-    else:
-        return torchvision.ops.misc.interpolate(input, size, scale_factor, mode, align_corners)
-
-
-class color_sys:
-    def __init__(self, num_colors) -> None:
-        self.num_colors = num_colors
-        colors = []
-        for i in np.arange(0.0, 360.0, 360.0 / num_colors):
-            hue = i / 360.0
-            lightness = (50 + np.random.rand() * 10) / 100.0
-            saturation = (90 + np.random.rand() * 10) / 100.0
-            colors.append(
-                tuple([int(j * 255) for j in colorsys.hls_to_rgb(hue, lightness, saturation)])
-            )
-        self.colors = colors
-
-    def __call__(self, idx):
-        return self.colors[idx]
-
-
-def inverse_sigmoid(x, eps=1e-3):
-    x = x.clamp(min=0, max=1)
-    x1 = x.clamp(min=eps)
-    x2 = (1 - x).clamp(min=eps)
-    return torch.log(x1 / x2)
-
-
-def clean_state_dict(state_dict):
-    new_state_dict = OrderedDict()
-    for k, v in state_dict.items():
-        if k[:7] == "module.":
-            k = k[7:]  # remove `module.`
-        new_state_dict[k] = v
-    return new_state_dict
diff --git a/spaces/shi-labs/Prompt-Free-Diffusion/lib/model_zoo/seecoder_utils.py b/spaces/shi-labs/Prompt-Free-Diffusion/lib/model_zoo/seecoder_utils.py
deleted file mode 100644
index 40acf4d8eb70cecc98aa46f999a6218c09b5bd0f..0000000000000000000000000000000000000000
--- a/spaces/shi-labs/Prompt-Free-Diffusion/lib/model_zoo/seecoder_utils.py
+++ /dev/null
@@ -1,108 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.nn.init import xavier_uniform_, constant_, uniform_, normal_
-import math
-import copy
-
-def _get_clones(module, N):
-    return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
-
-def _get_activation_fn(activation):
-    """Return an activation function given a string"""
-    if activation == "relu":
-        return F.relu
-    if activation == "gelu":
-        return F.gelu
-    if activation == "glu":
-        return F.glu
-    raise RuntimeError(f"activation should be relu/gelu, not {activation}.")
-
-def _is_power_of_2(n):
-    if (not isinstance(n, int)) or (n < 0):
-        raise ValueError("invalid input for _is_power_of_2: {} (type: {})".format(n, type(n)))
-    return (n & (n-1) == 0) and n != 0
-
-def c2_xavier_fill(module):
-    # Caffe2 implementation of XavierFill in fact
-    nn.init.kaiming_uniform_(module.weight, a=1)
-    if module.bias is not None:
-        nn.init.constant_(module.bias, 0)
-
-def with_pos_embed(x, pos):
-    return x if pos is None else x + pos
-
-class PositionEmbeddingSine(nn.Module):
-    def __init__(self, num_pos_feats=64, temperature=256, normalize=False, scale=None):
-        super().__init__()
-        self.num_pos_feats = num_pos_feats
-        self.temperature = temperature
-        self.normalize = normalize
-        if scale is not None and normalize is False:
-            raise ValueError("normalize should be True if scale is passed")
-        if scale is None:
-            scale = 2 * math.pi
-        self.scale = scale
-
-    def forward(self, x, mask=None):
-        if mask is None:
-            mask = torch.zeros((x.size(0), x.size(2), x.size(3)), device=x.device, dtype=torch.bool)
-        not_mask = ~mask
-        h, w = not_mask.shape[-2:]
-        minlen = min(h, w)
-        h_embed = not_mask.cumsum(1, dtype=torch.float32)
-        w_embed = not_mask.cumsum(2, dtype=torch.float32)
-        if self.normalize:
-            eps = 1e-6
-            h_embed = (h_embed - h/2) / (minlen + eps) * self.scale
-            w_embed = (w_embed - w/2) / (minlen + eps) * self.scale
-
-        dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
-        dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
-
-        pos_w = w_embed[:, :, :, None] / dim_t
-        pos_h = h_embed[:, :, :, None] / dim_t
-        pos_w = torch.stack(
-            (pos_w[:, :, :, 0::2].sin(), pos_w[:, :, :, 1::2].cos()), dim=4
-        ).flatten(3)
-        pos_h = torch.stack(
-            (pos_h[:, :, :, 0::2].sin(), pos_h[:, :, :, 1::2].cos()), dim=4
-        ).flatten(3)
-        pos = torch.cat((pos_h, pos_w), dim=3).permute(0, 3, 1, 2)
-        return pos
-    
-    def __repr__(self, _repr_indent=4):
-        head = "Positional encoding " + self.__class__.__name__
-        body = [
-            "num_pos_feats: {}".format(self.num_pos_feats),
-            "temperature: {}".format(self.temperature),
-            "normalize: {}".format(self.normalize),
-            "scale: {}".format(self.scale),
-        ]
-        # _repr_indent = 4
-        lines = [head] + [" " * _repr_indent + line for line in body]
-        return "\n".join(lines)
-
-class Conv2d_Convenience(nn.Conv2d):
-    def __init__(self, *args, **kwargs):
-        norm = kwargs.pop("norm", None)
-        activation = kwargs.pop("activation", None)
-        super().__init__(*args, **kwargs)
-        self.norm = norm
-        self.activation = activation
-
-    def forward(self, x):
-        if not torch.jit.is_scripting():
-            if x.numel() == 0 and self.training:
-                assert not isinstance(
-                    self.norm, torch.nn.SyncBatchNorm
-                ), "SyncBatchNorm does not support empty inputs!"
-        x = F.conv2d(
-            x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups
-        )
-        if self.norm is not None:
-            x = self.norm(x)
-        if self.activation is not None:
-            x = self.activation(x)
-        return x
-
diff --git a/spaces/shikunl/prismer/prismer/experts/obj_detection/unidet/modeling/backbone/resnest.py b/spaces/shikunl/prismer/prismer/experts/obj_detection/unidet/modeling/backbone/resnest.py
deleted file mode 100644
index 5e0384c0b104c38d59a8bd29131a6578e694eb1e..0000000000000000000000000000000000000000
--- a/spaces/shikunl/prismer/prismer/experts/obj_detection/unidet/modeling/backbone/resnest.py
+++ /dev/null
@@ -1,810 +0,0 @@
-# from https://github.com/chongruo/detectron2-ResNeSt/blob/resnest/detectron2/modeling/backbone/resnet.py
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-
-import numpy as np
-import fvcore.nn.weight_init as weight_init
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from detectron2.layers import (
-    Conv2d,
-    DeformConv,
-    FrozenBatchNorm2d,
-    ModulatedDeformConv,
-    ShapeSpec,
-    get_norm,
-)
-
-from detectron2.modeling.backbone import Backbone
-from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
-from detectron2.modeling.backbone.resnet import ResNetBlockBase
-from detectron2.modeling.backbone.fpn import FPN, LastLevelMaxPool, LastLevelP6P7
-
-__all__ = [
-    "ResNetBlockBase",
-    "BasicBlock",
-    "BottleneckBlock",
-    "DeformBottleneckBlock",
-    "BasicStem",
-    "ResNet",
-    "make_stage",
-    "build_resnet_backbone",
-]
-
-
-class ResNetBlockBase(nn.Module):
-    def __init__(self, in_channels, out_channels, stride):
-        """
-        The `__init__` method of any subclass should also contain these arguments.
-        Args:
-            in_channels (int):
-            out_channels (int):
-            stride (int):
-        """
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.stride = stride
-
-    def freeze(self):
-        for p in self.parameters():
-            p.requires_grad = False
-        FrozenBatchNorm2d.convert_frozen_batchnorm(self)
-        return self
-
-
-class BasicBlock(ResNetBlockBase):
-    def __init__(self, in_channels, out_channels, *, stride=1, norm="BN"):
-        """
-        The standard block type for ResNet18 and ResNet34.
-        Args:
-            in_channels (int): Number of input channels.
-            out_channels (int): Number of output channels.
-            stride (int): Stride for the first conv.
-            norm (str or callable): A callable that takes the number of
-                channels and returns a `nn.Module`, or a pre-defined string
-                (one of {"FrozenBN", "BN", "GN"}).
-        """
-        super().__init__(in_channels, out_channels, stride)
-
-        if in_channels != out_channels:
-            self.shortcut = Conv2d(
-                in_channels,
-                out_channels,
-                kernel_size=1,
-                stride=stride,
-                bias=False,
-                norm=get_norm(norm, out_channels),
-            )
-        else:
-            self.shortcut = None
-
-        self.conv1 = Conv2d(
-            in_channels,
-            out_channels,
-            kernel_size=3,
-            stride=stride,
-            padding=1,
-            bias=False,
-            norm=get_norm(norm, out_channels),
-        )
-
-        self.conv2 = Conv2d(
-            out_channels,
-            out_channels,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            bias=False,
-            norm=get_norm(norm, out_channels),
-        )
-
-        for layer in [self.conv1, self.conv2, self.shortcut]:
-            if layer is not None:  # shortcut can be None
-                weight_init.c2_msra_fill(layer)
-
-    def forward(self, x):
-        out = self.conv1(x)
-        out = F.relu_(out)
-        out = self.conv2(out)
-
-        if self.shortcut is not None:
-            shortcut = self.shortcut(x)
-        else:
-            shortcut = x
-
-        out += shortcut
-        out = F.relu_(out)
-        return out
-
-
-class BottleneckBlock(ResNetBlockBase):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        *,
-        bottleneck_channels,
-        stride=1,
-        num_groups=1,
-        norm="BN",
-        stride_in_1x1=False,
-        dilation=1,
-        avd=False,
-        avg_down=False,
-        radix=2,
-        bottleneck_width=64,
-    ):
-        """
-        Args:
-            norm (str or callable): a callable that takes the number of
-                channels and return a `nn.Module`, or a pre-defined string
-                (one of {"FrozenBN", "BN", "GN"}).
-            stride_in_1x1 (bool): when stride==2, whether to put stride in the
-                first 1x1 convolution or the bottleneck 3x3 convolution.
-        """
-        super().__init__(in_channels, out_channels, stride)
-
-        self.avd = avd and (stride>1)
-        self.avg_down = avg_down
-        self.radix = radix
-
-        cardinality = num_groups
-        group_width = int(bottleneck_channels * (bottleneck_width / 64.)) * cardinality 
-
-        if in_channels != out_channels:
-            if self.avg_down:
-                self.shortcut_avgpool = nn.AvgPool2d(kernel_size=stride, stride=stride, 
-                                                     ceil_mode=True, count_include_pad=False)
-                self.shortcut = Conv2d(
-                    in_channels,
-                    out_channels,
-                    kernel_size=1,
-                    stride=1,
-                    bias=False,
-                    norm=get_norm(norm, out_channels),
-                )
-            else:
-                self.shortcut = Conv2d(
-                    in_channels,
-                    out_channels,
-                    kernel_size=1,
-                    stride=stride,
-                    bias=False,
-                    norm=get_norm(norm, out_channels),
-                )
-        else:
-            self.shortcut = None
-
-        # The original MSRA ResNet models have stride in the first 1x1 conv
-        # The subsequent fb.torch.resnet and Caffe2 ResNe[X]t implementations have
-        # stride in the 3x3 conv
-        stride_1x1, stride_3x3 = (stride, 1) if stride_in_1x1 else (1, stride)
-
-        self.conv1 = Conv2d(
-            in_channels,
-            group_width,
-            kernel_size=1,
-            stride=stride_1x1,
-            bias=False,
-            norm=get_norm(norm, group_width),
-        )
-
-        if self.radix>1:
-            from .splat import SplAtConv2d
-            self.conv2 = SplAtConv2d(
-                            group_width, group_width, kernel_size=3, 
-                            stride = 1 if self.avd else stride_3x3,
-                            padding=dilation, dilation=dilation, 
-                            groups=cardinality, bias=False,
-                            radix=self.radix, 
-                            norm=norm,
-                         )
-        else:
-            self.conv2 = Conv2d(
-                group_width,
-                group_width,
-                kernel_size=3,
-                stride=1 if self.avd else stride_3x3,
-                padding=1 * dilation,
-                bias=False,
-                groups=num_groups,
-                dilation=dilation,
-                norm=get_norm(norm, group_width),
-            )
-
-        if self.avd:
-            self.avd_layer = nn.AvgPool2d(3, stride, padding=1)
-
-        self.conv3 = Conv2d(
-            group_width,
-            out_channels,
-            kernel_size=1,
-            bias=False,
-            norm=get_norm(norm, out_channels),
-        )
-
-        if self.radix>1:
-            for layer in [self.conv1, self.conv3, self.shortcut]:
-                if layer is not None:  # shortcut can be None
-                    weight_init.c2_msra_fill(layer)
-        else:
-            for layer in [self.conv1, self.conv2, self.conv3, self.shortcut]:
-                if layer is not None:  # shortcut can be None
-                    weight_init.c2_msra_fill(layer)
-
-        # Zero-initialize the last normalization in each residual branch,
-        # so that at the beginning, the residual branch starts with zeros,
-        # and each residual block behaves like an identity.
-        # See Sec 5.1 in "Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour":
-        # "For BN layers, the learnable scaling coefficient γ is initialized
-        # to be 1, except for each residual block's last BN
-        # where γ is initialized to be 0."
-
-        # nn.init.constant_(self.conv3.norm.weight, 0)
-        # TODO this somehow hurts performance when training GN models from scratch.
-        # Add it as an option when we need to use this code to train a backbone.
-
-    def forward(self, x):
-        out = self.conv1(x)
-        out = F.relu_(out)
-
-        if self.radix>1:
-            out = self.conv2(out)
-        else:
-            out = self.conv2(out)
-            out = F.relu_(out)
-
-        if self.avd:
-            out = self.avd_layer(out)
-
-        out = self.conv3(out)
-
-        if self.shortcut is not None:
-            if self.avg_down:
-                x = self.shortcut_avgpool(x) 
-            shortcut = self.shortcut(x)
-        else:
-            shortcut = x
-
-        out += shortcut
-        out = F.relu_(out)
-        return out
-
-
-class DeformBottleneckBlock(ResNetBlockBase):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        *,
-        bottleneck_channels,
-        stride=1,
-        num_groups=1,
-        norm="BN",
-        stride_in_1x1=False,
-        dilation=1,
-        deform_modulated=False,
-        deform_num_groups=1,
-        avd=False,
-        avg_down=False,
-        radix=2,
-        bottleneck_width=64,
-    ):
-        """
-        Similar to :class:`BottleneckBlock`, but with deformable conv in the 3x3 convolution.
-        """
-        super().__init__(in_channels, out_channels, stride)
-        self.deform_modulated = deform_modulated
-        self.avd = avd and (stride>1)
-        self.avg_down = avg_down
-        self.radix = radix
-
-        cardinality = num_groups
-        group_width = int(bottleneck_channels * (bottleneck_width / 64.)) * cardinality 
-
-        if in_channels != out_channels:
-            if self.avg_down:
-                self.shortcut_avgpool = nn.AvgPool2d(
-                    kernel_size=stride, stride=stride, 
-                    ceil_mode=True, count_include_pad=False)
-                self.shortcut = Conv2d(
-                    in_channels,
-                    out_channels,
-                    kernel_size=1,
-                    stride=1,
-                    bias=False,
-                    norm=get_norm(norm, out_channels),
-                )
-            else:
-                self.shortcut = Conv2d(
-                    in_channels,
-                    out_channels,
-                    kernel_size=1,
-                    stride=stride,
-                    bias=False,
-                    norm=get_norm(norm, out_channels),
-                )
-        else:
-            self.shortcut = None
-
-        stride_1x1, stride_3x3 = (stride, 1) if stride_in_1x1 else (1, stride)
-
-        self.conv1 = Conv2d(
-            in_channels,
-            group_width,
-            kernel_size=1,
-            stride=stride_1x1,
-            bias=False,
-            norm=get_norm(norm, group_width),
-        )
-
-        if deform_modulated:
-            deform_conv_op = ModulatedDeformConv
-            # offset channels are 2 or 3 (if with modulated) * kernel_size * kernel_size
-            offset_channels = 27
-        else:
-            deform_conv_op = DeformConv
-            offset_channels = 18
-
-        self.conv2_offset = Conv2d(
-            bottleneck_channels,
-            offset_channels * deform_num_groups,
-            kernel_size=3,
-            stride=1 if self.avd else stride_3x3,
-            padding=1 * dilation,
-            dilation=dilation,
-            groups=deform_num_groups,
-        )
-
-        if self.radix>1:
-            from .splat import SplAtConv2d_dcn
-            self.conv2 = SplAtConv2d_dcn(
-                            group_width, group_width, kernel_size=3, 
-                            stride = 1 if self.avd else stride_3x3,
-                            padding=dilation, dilation=dilation, 
-                            groups=cardinality, bias=False,
-                            radix=self.radix, 
-                            norm=norm,
-                            deform_conv_op=deform_conv_op,
-                            deformable_groups=deform_num_groups,
-                            deform_modulated=deform_modulated,
-
-                         )
-        else:
-            self.conv2 = deform_conv_op(
-                bottleneck_channels,
-                bottleneck_channels,
-                kernel_size=3,
-                stride=1 if self.avd else stride_3x3,
-                padding=1 * dilation,
-                bias=False,
-                groups=num_groups,
-                dilation=dilation,
-                deformable_groups=deform_num_groups,
-                norm=get_norm(norm, bottleneck_channels),
-            )
-
-        if self.avd:
-            self.avd_layer = nn.AvgPool2d(3, stride, padding=1)
-
-        self.conv3 = Conv2d(
-            group_width,
-            out_channels,
-            kernel_size=1,
-            bias=False,
-            norm=get_norm(norm, out_channels),
-        )
-
-        if self.radix>1:
-            for layer in [self.conv1, self.conv3, self.shortcut]:
-                if layer is not None:  # shortcut can be None
-                    weight_init.c2_msra_fill(layer)
-        else:
-            for layer in [self.conv1, self.conv2, self.conv3, self.shortcut]:
-                if layer is not None:  # shortcut can be None
-                    weight_init.c2_msra_fill(layer)
-
-        nn.init.constant_(self.conv2_offset.weight, 0)
-        nn.init.constant_(self.conv2_offset.bias, 0)
-
-    def forward(self, x):
-        out = self.conv1(x)
-        out = F.relu_(out)
-
-        if self.radix>1:
-            offset = self.conv2_offset(out)
-            out = self.conv2(out, offset)
-        else:
-            if self.deform_modulated:
-                offset_mask = self.conv2_offset(out)
-                offset_x, offset_y, mask = torch.chunk(offset_mask, 3, dim=1)
-                offset = torch.cat((offset_x, offset_y), dim=1)
-                mask = mask.sigmoid()
-                out = self.conv2(out, offset, mask)
-            else:
-                offset = self.conv2_offset(out)
-                out = self.conv2(out, offset)
-            out = F.relu_(out)
-
-        if self.avd:
-            out = self.avd_layer(out)
-
-        out = self.conv3(out)
-
-        if self.shortcut is not None:
-            if self.avg_down:
-                x = self.shortcut_avgpool(x) 
-            shortcut = self.shortcut(x)
-        else:
-            shortcut = x
-
-        out += shortcut
-        out = F.relu_(out)
-        return out
-
-
-def make_stage(block_class, num_blocks, first_stride, **kwargs):
-    """
-    Create a resnet stage by creating many blocks.
-    Args:
-        block_class (class): a subclass of ResNetBlockBase
-        num_blocks (int):
-        first_stride (int): the stride of the first block. The other blocks will have stride=1.
-            A `stride` argument will be passed to the block constructor.
-        kwargs: other arguments passed to the block constructor.
-    Returns:
-        list[nn.Module]: a list of block module.
-    """
-    blocks = []
-    for i in range(num_blocks):
-        blocks.append(block_class(stride=first_stride if i == 0 else 1, **kwargs))
-        kwargs["in_channels"] = kwargs["out_channels"]
-    return blocks
-
-
-class BasicStem(nn.Module):
-    def __init__(self, in_channels=3, out_channels=64, norm="BN",
-                 deep_stem=False, stem_width=32):
-        """
-        Args:
-            norm (str or callable): a callable that takes the number of
-                channels and return a `nn.Module`, or a pre-defined string
-                (one of {"FrozenBN", "BN", "GN"}).
-        """
-        super().__init__()
-        self.deep_stem = deep_stem
-
-        if self.deep_stem:
-            self.conv1_1 = Conv2d(3, stem_width, kernel_size=3, stride=2, 
-                                  padding=1, bias=False,
-                                  norm=get_norm(norm, stem_width),
-                                 ) 
-            self.conv1_2 = Conv2d(stem_width, stem_width, kernel_size=3, stride=1,
-                                  padding=1, bias=False,
-                                  norm=get_norm(norm, stem_width),
-                                 ) 
-            self.conv1_3 = Conv2d(stem_width, stem_width*2, kernel_size=3, stride=1,
-                                  padding=1, bias=False,
-                                  norm=get_norm(norm, stem_width*2),
-                                 ) 
-            for layer in [self.conv1_1, self.conv1_2, self.conv1_3]:
-                if layer is not None:  
-                    weight_init.c2_msra_fill(layer)
-        else:
-            self.conv1 = Conv2d(
-                in_channels,
-                out_channels,
-                kernel_size=7,
-                stride=2,
-                padding=3,
-                bias=False,
-                norm=get_norm(norm, out_channels),
-            )
-            weight_init.c2_msra_fill(self.conv1)
-
-    def forward(self, x):
-        if self.deep_stem:
-            x = self.conv1_1(x)
-            x = F.relu_(x)
-            x = self.conv1_2(x)
-            x = F.relu_(x)
-            x = self.conv1_3(x)
-            x = F.relu_(x)
-        else:
-            x = self.conv1(x)
-            x = F.relu_(x)
-        x = F.max_pool2d(x, kernel_size=3, stride=2, padding=1)
-        return x
-
-    @property
-    def out_channels(self):
-        if self.deep_stem:
-            return self.conv1_3.out_channels
-        else:
-            return self.conv1.out_channels
-
-    @property
-    def stride(self):
-        return 4  # = stride 2 conv -> stride 2 max pool
-
-
-class ResNet(Backbone):
-    def __init__(self, stem, stages, num_classes=None, out_features=None):
-        """
-        Args:
-            stem (nn.Module): a stem module
-            stages (list[list[ResNetBlock]]): several (typically 4) stages,
-                each contains multiple :class:`ResNetBlockBase`.
-            num_classes (None or int): if None, will not perform classification.
-            out_features (list[str]): name of the layers whose outputs should
-                be returned in forward. Can be anything in "stem", "linear", or "res2" ...
-                If None, will return the output of the last layer.
-        """
-        super(ResNet, self).__init__()
-        self.stem = stem
-        self.num_classes = num_classes
-
-        current_stride = self.stem.stride
-        self._out_feature_strides = {"stem": current_stride}
-        self._out_feature_channels = {"stem": self.stem.out_channels}
-
-        self.stages_and_names = []
-        for i, blocks in enumerate(stages):
-            for block in blocks:
-                assert isinstance(block, ResNetBlockBase), block
-                curr_channels = block.out_channels
-            stage = nn.Sequential(*blocks)
-            name = "res" + str(i + 2)
-            self.add_module(name, stage)
-            self.stages_and_names.append((stage, name))
-            self._out_feature_strides[name] = current_stride = int(
-                current_stride * np.prod([k.stride for k in blocks])
-            )
-            self._out_feature_channels[name] = blocks[-1].out_channels
-
-        if num_classes is not None:
-            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-            self.linear = nn.Linear(curr_channels, num_classes)
-
-            # Sec 5.1 in "Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour":
-            # "The 1000-way fully-connected layer is initialized by
-            # drawing weights from a zero-mean Gaussian with standard deviation of 0.01."
-            nn.init.normal_(self.linear.weight, std=0.01)
-            name = "linear"
-
-        if out_features is None:
-            out_features = [name]
-        self._out_features = out_features
-        assert len(self._out_features)
-        children = [x[0] for x in self.named_children()]
-        for out_feature in self._out_features:
-            assert out_feature in children, "Available children: {}".format(", ".join(children))
-
-    def forward(self, x):
-        outputs = {}
-        x = self.stem(x)
-        if "stem" in self._out_features:
-            outputs["stem"] = x
-        for stage, name in self.stages_and_names:
-            x = stage(x)
-            if name in self._out_features:
-                outputs[name] = x
-        if self.num_classes is not None:
-            x = self.avgpool(x)
-            x = torch.flatten(x, 1)
-            x = self.linear(x)
-            if "linear" in self._out_features:
-                outputs["linear"] = x
-        return outputs
-
-    def output_shape(self):
-        return {
-            name: ShapeSpec(
-                channels=self._out_feature_channels[name], stride=self._out_feature_strides[name]
-            )
-            for name in self._out_features
-        }
-
-
-@BACKBONE_REGISTRY.register()
-def build_resnest_backbone(cfg, input_shape):
-    """
-    Create a ResNet instance from config.
-    Returns:
-        ResNet: a :class:`ResNet` instance.
-    """
-
-    depth = cfg.MODEL.RESNETS.DEPTH
-    stem_width = {50: 32, 101: 64, 152: 64, 200: 64, 269: 64}[depth] 
-    radix = cfg.MODEL.RESNETS.RADIX 
-    deep_stem = cfg.MODEL.RESNETS.DEEP_STEM or (radix > 1)
-
-    # need registration of new blocks/stems?
-    norm = cfg.MODEL.RESNETS.NORM
-    stem = BasicStem(
-        in_channels=input_shape.channels,
-        out_channels=cfg.MODEL.RESNETS.STEM_OUT_CHANNELS,
-        norm=norm,
-        deep_stem=deep_stem,
-        stem_width=stem_width,
-    )
-    freeze_at = cfg.MODEL.BACKBONE.FREEZE_AT
-
-    if freeze_at >= 1:
-        for p in stem.parameters():
-            p.requires_grad = False
-        stem = FrozenBatchNorm2d.convert_frozen_batchnorm(stem)
-
-    # fmt: off
-    out_features        = cfg.MODEL.RESNETS.OUT_FEATURES
-    num_groups          = cfg.MODEL.RESNETS.NUM_GROUPS
-    width_per_group     = cfg.MODEL.RESNETS.WIDTH_PER_GROUP
-    bottleneck_channels = num_groups * width_per_group
-    in_channels         = cfg.MODEL.RESNETS.STEM_OUT_CHANNELS
-    out_channels        = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS
-    stride_in_1x1       = cfg.MODEL.RESNETS.STRIDE_IN_1X1
-    res5_dilation       = cfg.MODEL.RESNETS.RES5_DILATION
-    deform_on_per_stage = cfg.MODEL.RESNETS.DEFORM_ON_PER_STAGE
-    deform_modulated    = cfg.MODEL.RESNETS.DEFORM_MODULATED
-    deform_num_groups   = cfg.MODEL.RESNETS.DEFORM_NUM_GROUPS
-    avd                 = cfg.MODEL.RESNETS.AVD or (radix > 1)
-    avg_down            = cfg.MODEL.RESNETS.AVG_DOWN or (radix > 1)
-    bottleneck_width    = cfg.MODEL.RESNETS.BOTTLENECK_WIDTH
-    # fmt: on
-    assert res5_dilation in {1, 2}, "res5_dilation cannot be {}.".format(res5_dilation)
-
-    num_blocks_per_stage = {
-        18: [2, 2, 2, 2],
-        34: [3, 4, 6, 3],
-        50: [3, 4, 6, 3],
-        101: [3, 4, 23, 3],
-        152: [3, 8, 36, 3],
-        200: [3, 24, 36, 3],
-        269: [3, 30, 48, 8],
-    }[depth]
-
-    if depth in [18, 34]:
-        assert out_channels == 64, "Must set MODEL.RESNETS.RES2_OUT_CHANNELS = 64 for R18/R34"
-        assert not any(
-            deform_on_per_stage
-        ), "MODEL.RESNETS.DEFORM_ON_PER_STAGE unsupported for R18/R34"
-        assert res5_dilation == 1, "Must set MODEL.RESNETS.RES5_DILATION = 1 for R18/R34"
-        assert num_groups == 1, "Must set MODEL.RESNETS.NUM_GROUPS = 1 for R18/R34"
-
-    stages = []
-
-    # Avoid creating variables without gradients
-    # It consumes extra memory and may cause allreduce to fail
-    out_stage_idx = [{"res2": 2, "res3": 3, "res4": 4, "res5": 5}[f] for f in out_features]
-    max_stage_idx = max(out_stage_idx)
-    in_channels = 2*stem_width if deep_stem else in_channels
-    for idx, stage_idx in enumerate(range(2, max_stage_idx + 1)):
-        dilation = res5_dilation if stage_idx == 5 else 1
-        first_stride = 1 if idx == 0 or (stage_idx == 5 and dilation == 2) else 2
-        stage_kargs = {
-            "num_blocks": num_blocks_per_stage[idx],
-            "first_stride": first_stride,
-            "in_channels": in_channels,
-            "out_channels": out_channels,
-            "norm": norm,
-            "avd": avd,
-            "avg_down": avg_down,
-            "radix": radix,
-            "bottleneck_width": bottleneck_width,
-        }
-        # Use BasicBlock for R18 and R34.
-        if depth in [18, 34]:
-            stage_kargs["block_class"] = BasicBlock
-        else:
-            stage_kargs["bottleneck_channels"] = bottleneck_channels
-            stage_kargs["stride_in_1x1"] = stride_in_1x1
-            stage_kargs["dilation"] = dilation
-            stage_kargs["num_groups"] = num_groups
-            if deform_on_per_stage[idx]:
-                stage_kargs["block_class"] = DeformBottleneckBlock
-                stage_kargs["deform_modulated"] = deform_modulated
-                stage_kargs["deform_num_groups"] = deform_num_groups
-            else:
-                stage_kargs["block_class"] = BottleneckBlock
-        blocks = make_stage(**stage_kargs)
-        in_channels = out_channels
-        out_channels *= 2
-        bottleneck_channels *= 2
-
-        if freeze_at >= stage_idx:
-            for block in blocks:
-                block.freeze()
-        stages.append(blocks)
-    return ResNet(stem, stages, out_features=out_features)
-
-
-
-@BACKBONE_REGISTRY.register()
-def build_resnest_fpn_backbone(cfg, input_shape: ShapeSpec):
-    """
-    Args:
-        cfg: a detectron2 CfgNode
-
-    Returns:
-        backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`.
-    """
-    bottom_up = build_resnest_backbone(cfg, input_shape)
-    in_features = cfg.MODEL.FPN.IN_FEATURES
-    out_channels = cfg.MODEL.FPN.OUT_CHANNELS
-    backbone = FPN(
-        bottom_up=bottom_up,
-        in_features=in_features,
-        out_channels=out_channels,
-        norm=cfg.MODEL.FPN.NORM,
-        top_block=LastLevelMaxPool(),
-        fuse_type=cfg.MODEL.FPN.FUSE_TYPE,
-    )
-    return backbone
-
-
-@BACKBONE_REGISTRY.register()
-def build_retinanet_resnest_fpn_backbone(cfg, input_shape: ShapeSpec):
-    """
-    Args:
-        cfg: a detectron2 CfgNode
-
-    Returns:
-        backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`.
-    """
-    bottom_up = build_resnest_backbone(cfg, input_shape)
-    in_features = cfg.MODEL.FPN.IN_FEATURES
-    out_channels = cfg.MODEL.FPN.OUT_CHANNELS
-    in_channels_p6p7 = bottom_up.output_shape()["res5"].channels
-    backbone = FPN(
-        bottom_up=bottom_up,
-        in_features=in_features,
-        out_channels=out_channels,
-        norm=cfg.MODEL.FPN.NORM,
-        top_block=LastLevelP6P7(in_channels_p6p7, out_channels),
-        fuse_type=cfg.MODEL.FPN.FUSE_TYPE,
-    )
-    return backbone
-
-class LastLevelP6P7_P5(nn.Module):
-    """
-    This module is used in RetinaNet to generate extra layers, P6 and P7 from
-    C5 feature.
-    """
-
-    def __init__(self, in_channels, out_channels):
-        super().__init__()
-        self.num_levels = 2
-        self.in_feature = "p5"
-        self.p6 = nn.Conv2d(in_channels, out_channels, 3, 2, 1)
-        self.p7 = nn.Conv2d(out_channels, out_channels, 3, 2, 1)
-        for module in [self.p6, self.p7]:
-            weight_init.c2_xavier_fill(module)
-
-    def forward(self, c5):
-        p6 = self.p6(c5)
-        p7 = self.p7(F.relu(p6))
-        return [p6, p7]
-
-@BACKBONE_REGISTRY.register()
-def build_p67_resnest_fpn_backbone(cfg, input_shape: ShapeSpec):
-    """
-    Args:
-        cfg: a detectron2 CfgNode
-
-    Returns:
-        backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`.
-    """
-    bottom_up = build_resnest_backbone(cfg, input_shape)
-    in_features = cfg.MODEL.FPN.IN_FEATURES
-    out_channels = cfg.MODEL.FPN.OUT_CHANNELS
-    backbone = FPN(
-        bottom_up=bottom_up,
-        in_features=in_features,
-        out_channels=out_channels,
-        norm=cfg.MODEL.FPN.NORM,
-        top_block=LastLevelP6P7_P5(out_channels, out_channels),
-        fuse_type=cfg.MODEL.FPN.FUSE_TYPE,
-    )
-    return backbone
\ No newline at end of file
diff --git a/spaces/silencewing/server/youyou/.history/math_20230613230827.html b/spaces/silencewing/server/youyou/.history/math_20230613230827.html
deleted file mode 100644
index 3b7b175a9d1eddafe65342f6bf1c347a081f3766..0000000000000000000000000000000000000000
--- a/spaces/silencewing/server/youyou/.history/math_20230613230827.html
+++ /dev/null
@@ -1,227 +0,0 @@
-<!-- /*
- * @Author: Chauncey Yuan 
- * @Date: 2019-08-01 18:25:30 
- * @Last Modified by:   Chauncey Yuan 
- * @Last Modified time: 2019-08-03 08:24:27 
- */ -->
-
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta http-equiv="X-UA-Compatible" content="ie=edge">
-    <title>Document</title>
-    <style>
-        html {
-            height: 100%;
-            background: #b3b4a6;
-        }
-        .cal_game {
-            width: 650px;
-            margin: 0 auto;
-        }
-        
-        table {
-            margin: 0 auto;
-        }
-        
-        td {
-            width: 150px;
-            height: 50px;
-            text-align: center;
-            line-height: 40px;
-            border: 1px solid #2b7e71;
-        }
-        
-        .btn {
-            width: 150px;
-            height: 50px;
-            color: #2b7e71;;
-            border: 1px solid #2b7e71;
-            background-color: transparent;
-            /* background-color: #fff; */
-        }
-        
-        .btn:hover {
-            background-color: #2b7e71;
-            color: #fff;
-            cursor: pointer;
-        }
-        
-        input {
-            height: 30px;
-            border: 1px solid #999999;
-            background-color: transparent;
-
-        }
-    </style>
-</head>
-
-<body>
-    <div class="cal_game">
-        <table>
-            <tr>
-                <td id="output" colspan="3"></td>
-            </tr>
-            <tr>
-                <td>题目</td>
-                <td id="eq" colspan="2"></td>
-            </tr>
-            <tr>
-                <td>答案</td>
-                <td colspan="2"><input type="text" name="" id="input" placeholder="请输入计算结果："></td>
-                <!-- <td><button class="btn" onclick="xun()">计算</button></td> -->
-            </tr>
-            <tr>
-                <td>正误</td>
-                <td id="result" colspan="2"></td>
-            </tr>
-            <tr>
-                <td>得分</td>
-                <td id="score" colspan="2"></td>
-            </tr>
-            <tr>
-                <td id="accuracy" colspan="3"></td>
-            </tr>
-        </table>
-    </div>
-    <script>
-        // 定义题号，使用时+1
-        var i = 0;
-        // 定义计算正确的次数
-        var right_times = 0;
-        // 定义分数
-        var score = 0;
-        // 定义正确率
-        var accuracy = 0;
-        // 定义加减法符号数组，用于后边产生0或1的随机数，来确定加减法
-        var sign_operation_list = ["+", "-"];
-        // 生成0或者1的随机数，确定加减法
-        var sign_operation = Math.floor((Math.random() * (1 - 0 + 1)) + 0);
-
-        var max_num = 20;
-        // 显示题号
-        document.getElementById("output").innerHTML = "第" + (i + 1) + "题";
-        document.onkeydown = function (e) {
-            if(e.which == "13" && document.getElementById("input").value){
-                xun()
-            }
-        }
-
-        // 如果是减法
-        if (sign_operation == 1) {
-            // 则被减数应该小于减数，结果才不会为负数
-            // 减数范围为0-max_num
-            var num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-            // 被减数范围为0-减数
-            var num2 = Math.floor(Math.random() * (num1 - 0 + 1) + 0);
-        }
-        // 如果是加法
-        if (sign_operation == 0) {
-            // 两数和应小于max_num
-            // 第一个数的范围是0-max_num
-            var num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-            // 第二个数是0-（max_num-第一个数）
-            var num2 = Math.floor(Math.random() * (max_num - num1 - 0 + 1) + 0);
-        }
-        // 组成算式，显示给用户看
-        var eq = String(num1) + sign_operation_list[sign_operation] + String(num2) + "=";
-        // 页面中显示算式
-        document.getElementById("eq").innerHTML = eq;
-        // console.log(eq);
-
-        // 定义函数，当按钮按下是执行一次
-        function xun() {
-            // console.log(num1, num2);
-            // 题号加1
-            i++;
-            // 获取用户输入的结果
-            var input = Number(document.getElementById("input").value);
-            // console.log(input, num1, num2);
-            // 如果是加法
-            if (sign_operation == 0) {
-                // 定义真实结果
-                var calResult = num1 + num2;
-                // 如果用户输入的结果和真实结果相同
-                if (input == calResult) {
-                    // 分数加10分
-                    score += 10;
-                    // console.log("正确！");
-                    // 显示正确信息
-                    document.getElementById("result").innerHTML = "正确";
-                    // 正确的次数加1
-                    right_times++;
-                }
-                // 如果用户输入的结果和真实结果不同
-                if (input != calResult) {
-                    // 分数减10分
-                    score -= 10;
-                    // console.log("错误！");
-                    // 显示错误信息
-                    document.getElementById("result").innerHTML = "错误";
-                }
-            } // 如果是减法
-            if (sign_operation == 1) {
-                // 定义真实结果
-                var calResult = num1 - num2;
-                // 如果用户输入的结果和真实结果相同
-                if (input == calResult) {
-                    // 分数加10分
-                    score += 10;
-                    // console.log("正确！");
-                    // 显示正确信息
-                    document.getElementById("result").innerHTML = "正确";
-                    // 正确的次数加1
-                    right_times++;
-                }
-                // 如果用户输入的结果和真实结果不同
-                if (input != calResult) {
-                    // 分数减10分
-                    score -= 10;
-                    // console.log("错误！");
-                    // 显示错误信息
-                    document.getElementById("result").innerHTML = "错误";
-                }
-            }
-            // 判断结果后，用户输入框清空
-            document.getElementById("input").value = "";
-            // 显示分数
-            document.getElementById("score").innerHTML = score;
-            // 显示正确率
-            document.getElementById("accuracy").innerHTML = (((right_times / i) * 100).toFixed(2)) + "%";
-
-            if (score >= 100) {
-                window.location.href = "game.html";
-            }
-            // 生成0或者1的随机数，确定加减法
-            sign_operation = Math.floor((Math.random() * (1 - 0 + 1)) + 0);
-            // 显示题号
-            document.getElementById("output").innerHTML = "第" + (i + 1) + "题";
-            // 如果是减法
-            if (sign_operation == 1) {
-                // 则被减数应该小于减数，结果才不会为负数
-                // 减数范围为0-max_num
-                num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-                // 被减数范围为0-减数
-                num2 = Math.floor(Math.random() * (num1 - 0 + 1) + 0);
-            }
-            // 如果是加法
-            if (sign_operation == 0) {
-                // 两数和应小于max_num
-                // 第一个数的范围是0-max_num
-                num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-                // 第二个数是0-（max_num-第一个数）
-                num2 = Math.floor(Math.random() * (max_num - num1 - 0 + 1) + 0);
-            }
-            // 组成算式，显示给用户看
-            eq = String(num1) + sign_operation_list[sign_operation] + String(num2) + "=";
-            // 页面中显示算式
-            document.getElementById("eq").innerHTML = eq;
-            // console.log(eq);
-        }
-    </script>
-</body>
-
-</html>
diff --git a/spaces/silencewing/server/youyou/.history/math_20230613232511.html b/spaces/silencewing/server/youyou/.history/math_20230613232511.html
deleted file mode 100644
index 31db495e1536a654c7e5ec1a22e10024688565a0..0000000000000000000000000000000000000000
--- a/spaces/silencewing/server/youyou/.history/math_20230613232511.html
+++ /dev/null
@@ -1,234 +0,0 @@
-<!-- /*
- * @Author: Chauncey Yuan 
- * @Date: 2019-08-01 18:25:30 
- * @Last Modified by:   Chauncey Yuan 
- * @Last Modified time: 2019-08-03 08:24:27 
- */ -->
-
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta http-equiv="X-UA-Compatible" content="ie=edge">
-    <title>Document</title>
-    <style>
-        html {
-            height: 100%;
-            background: #b3b4a6;
-        }
-        .cal_game {
-            width: 650px;
-            margin: 0 auto;
-        }
-        
-        table {
-            margin: 0 auto;
-        }
-        
-        td {
-            width: 150px;
-            height: 50px;
-            text-align: center;
-            line-height: 40px;
-            border: 1px solid #2b7e71;
-        }
-        
-        /* .btn {
-            width: 150px;
-            height: 50px;
-            color: #2b7e71;;
-            border: 1px solid #2b7e71;
-            background-color: transparent;
-        }
-        
-        .btn:hover {
-            background-color: #2b7e71;
-            color: #fff;
-            cursor: pointer;
-        } */
-        
-        input {
-            height: 30px;
-            border: 1px solid #999999;
-            background-color: transparent;
-
-        }
-
-        /* input:hover {
-            border: 3px solid #314834;
-
-        } */
-    </style>
-</head>
-
-<body>
-    <div class="cal_game">
-        <table>
-            <tr>
-                <td id="output" colspan="3"></td>
-            </tr>
-            <tr>
-                <td>题目</td>
-                <td id="eq" colspan="2"></td>
-            </tr>
-            <tr>
-                <td>答案</td>
-                <td colspan="2"><input type="text" name="" id="input" placeholder="请输入计算结果："></td>
-                <!-- <td><button class="btn" onclick="xun()">计算</button></td> -->
-            </tr>
-            <tr>
-                <td>正误</td>
-                <td id="result" colspan="2"></td>
-            </tr>
-            <tr>
-                <td>得分</td>
-                <td id="score" colspan="2"></td>
-            </tr>
-            <tr>
-                <td id="accuracy" colspan="3"></td>
-            </tr>
-        </table>
-    </div>
-    <script>
-        // 定义题号，使用时+1
-        var i = 0;
-        // 定义计算正确的次数
-        var right_times = 0;
-        // 定义分数
-        var score = 0;
-        // 定义正确率
-        var accuracy = 0;
-        // 定义加减法符号数组，用于后边产生0或1的随机数，来确定加减法
-        var sign_operation_list = ["+", "-"];
-        // 生成0或者1的随机数，确定加减法
-        var sign_operation = Math.floor((Math.random() * (1 - 0 + 1)) + 0);
-
-        var max_num = 20;
-        // 显示题号
-        document.getElementById("output").innerHTML = "第" + (i + 1) + "题";
-        document.onkeydown = function (e) {
-            if(e.which == "13" && document.getElementById("input").value){
-                xun()
-            }
-            else{
-                document.getElementById("input").focus()
-            }
-        }
-
-        // 如果是减法
-        if (sign_operation == 1) {
-            // 则被减数应该小于减数，结果才不会为负数
-            // 减数范围为0-max_num
-            var num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-            // 被减数范围为0-减数
-            var num2 = Math.floor(Math.random() * (num1 - 0 + 1) + 0);
-        }
-        // 如果是加法
-        if (sign_operation == 0) {
-            // 两数和应小于max_num
-            // 第一个数的范围是0-max_num
-            var num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-            // 第二个数是0-（max_num-第一个数）
-            var num2 = Math.floor(Math.random() * (max_num - num1 - 0 + 1) + 0);
-        }
-        // 组成算式，显示给用户看
-        var eq = String(num1) + sign_operation_list[sign_operation] + String(num2) + "=";
-        // 页面中显示算式
-        document.getElementById("eq").innerHTML = eq;
-        // console.log(eq);
-
-        // 定义函数，当按钮按下是执行一次
-        function xun() {
-            // console.log(num1, num2);
-            // 题号加1
-            i++;
-            // 获取用户输入的结果
-            var input = Number(document.getElementById("input").value);
-            // console.log(input, num1, num2);
-            // 如果是加法
-            if (sign_operation == 0) {
-                // 定义真实结果
-                var calResult = num1 + num2;
-                // 如果用户输入的结果和真实结果相同
-                if (input == calResult) {
-                    // 分数加10分
-                    score += 10;
-                    // console.log("正确！");
-                    // 显示正确信息
-                    document.getElementById("result").innerHTML = "正确";
-                    // 正确的次数加1
-                    right_times++;
-                }
-                // 如果用户输入的结果和真实结果不同
-                if (input != calResult) {
-                    // 分数减10分
-                    score -= 10;
-                    // console.log("错误！");
-                    // 显示错误信息
-                    document.getElementById("result").innerHTML = "错误：" + String(num1) + sign_operation_list[sign_operation] + String(num2) + "="+ calResult;
-                }
-            } // 如果是减法
-            if (sign_operation == 1) {
-                // 定义真实结果
-                var calResult = num1 - num2;
-                // 如果用户输入的结果和真实结果相同
-                if (input == calResult) {
-                    // 分数加10分
-                    score += 10;
-                    // console.log("正确！");
-                    // 显示正确信息
-                    document.getElementById("result").innerHTML = "正确";
-                    // 正确的次数加1
-                    right_times++;
-                }
-                // 如果用户输入的结果和真实结果不同
-                if (input != calResult) {
-                    // 分数减10分
-                    score -= 10;
-                    // console.log("错误！");
-                    // 显示错误信息
-                    document.getElementById("result").innerHTML = "错误： " + String(num1) + sign_operation_list[sign_operation] + String(num2) + "="+ calResult;
-                }
-            }
-            // 判断结果后，用户输入框清空
-            document.getElementById("input").value = "";
-            // 显示分数
-            document.getElementById("score").innerHTML = score;
-            // 显示正确率
-            document.getElementById("accuracy").innerHTML = (((right_times / i) * 100).toFixed(2)) + "%";
-
-            if (score >= 200) {
-                window.location.href = "game.html";
-            }
-            // 生成0或者1的随机数，确定加减法
-            sign_operation = Math.floor((Math.random() * (1 - 0 + 1)) + 0);
-            // 显示题号
-            document.getElementById("output").innerHTML = "第" + (i + 1) + "题";
-            // 如果是减法
-            if (sign_operation == 1) {
-                // 则被减数应该小于减数，结果才不会为负数
-                // 减数范围为0-max_num
-                num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-                // 被减数范围为0-减数
-                num2 = Math.floor(Math.random() * (num1 - 0 + 1) + 0);
-            }
-            // 如果是加法
-            if (sign_operation == 0) {
-                // 两数和应小于max_num
-                // 第一个数的范围是0-max_num
-                num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-                // 第二个数是0-（max_num-第一个数）
-                num2 = Math.floor(Math.random() * (max_num - num1 - 0 + 1) + 0);
-            }
-            // 组成算式，显示给用户看
-            eq = String(num1) + sign_operation_list[sign_operation] + String(num2) + "=";
-            // 页面中显示算式
-            document.getElementById("eq").innerHTML = eq;
-            // console.log(eq);
-        }
-    </script>
-</body>
-
-</html>
diff --git a/spaces/silencewing/server/youyou/math.html b/spaces/silencewing/server/youyou/math.html
deleted file mode 100644
index 5b830507cc4d6d8a225b84b06fb9d528f30e99de..0000000000000000000000000000000000000000
--- a/spaces/silencewing/server/youyou/math.html
+++ /dev/null
@@ -1,188 +0,0 @@
-<!-- /*
- * @Author: Chauncey Yuan 
- * @Date: 2019-08-01 18:25:30 
- * @Last Modified by:   Chauncey Yuan 
- * @Last Modified time: 2019-08-03 08:24:27 
- */ -->
-
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta http-equiv="X-UA-Compatible" content="ie=edge">
-    <title>Document</title>
-    <script src="js/main.js"></script>
-    <link rel="stylesheet" type="text/css" href="css/style.css">
-</head>
-
-<body>
-    <div class="cal_game">
-        <table>
-            <tr>
-                <td id="output" colspan="3"></td>
-            </tr>
-            <tr>
-                <th>题目</th>
-                <td id="eq" colspan="2"></td>
-            </tr>
-            <tr>
-                <th>答案</th>
-                <td colspan="2"><input type="text" name="" id="input" placeholder="请输入结果："></td>
-            </tr>
-            <tr>
-                <th>正误</th>
-                <td id="result" colspan="2"></td>
-            </tr>
-            <tr>
-                <th>得分</th>
-                <td id="score" colspan="2"></td>
-            </tr>
-            <tr>
-                <td id="accuracy" colspan="3"></td>
-            </tr>
-        </table>
-    </div>
-    <script>
-        // 定义题号，使用时+1
-        var i = 0;
-        // 定义计算正确的次数
-        var right_times = 0;
-        // 定义分数
-        var score = 0;
-        // 定义正确率
-        var accuracy = 0;
-        // 定义加减法符号数组，用于后边产生0或1的随机数，来确定加减法
-        var sign_operation_list = ["+", "-"];
-        // 生成0或者1的随机数，确定加减法
-        var sign_operation = Math.floor((Math.random() * (1 - 0 + 1)) + 0);
-
-        var max_num = 20;
-        // 显示题号
-        document.getElementById("output").innerHTML = "第   " + (i + 1) + "   题";
-        document.onkeydown = function (e) {
-            if(e.which == "13" && document.getElementById("input").value){
-                xun()
-            }
-            else{
-                document.getElementById("input").focus()
-            }
-        }
-
-        // 如果是减法
-        if (sign_operation == 1) {
-            // 则被减数应该小于减数，结果才不会为负数
-            // 减数范围为0-max_num
-            var num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-            // 被减数范围为0-减数
-            var num2 = Math.floor(Math.random() * (num1 - 0 + 1) + 0);
-        }
-        // 如果是加法
-        if (sign_operation == 0) {
-            // 两数和应小于max_num
-            // 第一个数的范围是0-max_num
-            var num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-            // 第二个数是0-（max_num-第一个数）
-            var num2 = Math.floor(Math.random() * (max_num - num1 - 0 + 1) + 0);
-        }
-        // 组成算式，显示给用户看
-        var eq = String(num1) + "  " + sign_operation_list[sign_operation] +  "  " + String(num2) + "  =  ";
-        // 页面中显示算式
-        document.getElementById("eq").innerHTML = eq;
-
-        downInit();
-        // console.log(eq);
-
-        // 定义函数，当按钮按下是执行一次
-        function xun() {
-            // console.log(num1, num2);
-            // 题号加1
-            i++;
-            // 获取用户输入的结果
-            var input = Number(document.getElementById("input").value);
-            // console.log(input, num1, num2);
-            // 如果是加法
-            if (sign_operation == 0) {
-                // 定义真实结果
-                var calResult = num1 + num2;
-                // 如果用户输入的结果和真实结果相同
-                if (input == calResult) {
-                    // 分数加10分
-                    score += 10;
-                    // console.log("正确！");
-                    // 显示正确信息
-                    document.getElementById("result").innerHTML = resultImg("正确");
-                    // 正确的次数加1
-                    right_times++;
-                }
-                // 如果用户输入的结果和真实结果不同
-                if (input != calResult) {
-                    // 分数减10分
-                    score -= 10;
-                    // console.log("错误！");
-                    // 显示错误信息
-                    document.getElementById("result").innerHTML = resultImg("错误") + "  " + String(num1) + "  " + sign_operation_list[sign_operation] + "  " + String(num2) + "  =  "+ calResult;
-                }
-            } // 如果是减法
-            if (sign_operation == 1) {
-                // 定义真实结果
-                var calResult = num1 - num2;
-                // 如果用户输入的结果和真实结果相同
-                if (input == calResult) {
-                    // 分数加10分
-                    score += 10;
-                    // console.log("正确！");
-                    // 显示正确信息
-                    document.getElementById("result").innerHTML = resultImg("正确");
-                    right_times++;
-                }
-                // 如果用户输入的结果和真实结果不同
-                if (input != calResult) {
-                    // 分数减10分
-                    score -= 10;
-                    // console.log("错误！");
-                    // 显示错误信息
-                    document.getElementById("result").innerHTML = resultImg("错误") + "  " + String(num1) + "  " + sign_operation_list[sign_operation] + "  " + String(num2) + "  =  "+ calResult;
-                }
-            }
-            // 判断结果后，用户输入框清空
-            document.getElementById("input").value = "";
-            // 显示分数
-            document.getElementById("score").innerHTML = score;
-            // 显示正确率
-            document.getElementById("accuracy").innerHTML = (((right_times / i) * 100).toFixed(2)) + "%";
-
-            if (score >= max_score) {
-                window.location.href = "game.html";
-            }
-            // 生成0或者1的随机数，确定加减法
-            sign_operation = Math.floor((Math.random() * (1 - 0 + 1)) + 0);
-            // 显示题号
-            document.getElementById("output").innerHTML = "第   " + (i + 1) + "   题";
-            // 如果是减法
-            if (sign_operation == 1) {
-                // 则被减数应该小于减数，结果才不会为负数
-                // 减数范围为0-max_num
-                num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-                // 被减数范围为0-减数
-                num2 = Math.floor(Math.random() * (num1 - 0 + 1) + 0);
-            }
-            // 如果是加法
-            if (sign_operation == 0) {
-                // 两数和应小于max_num
-                // 第一个数的范围是0-max_num
-                num1 = Math.floor(Math.random() * (max_num - 0 + 1) + 0);
-                // 第二个数是0-（max_num-第一个数）
-                num2 = Math.floor(Math.random() * (max_num - num1 - 0 + 1) + 0);
-            }
-            // 组成算式，显示给用户看
-            eq = String(num1) + "  " + sign_operation_list[sign_operation] +  "  " + String(num2) + "  =  ";//String(num1) + sign_operation_list[sign_operation] + String(num2) + "=";
-            // 页面中显示算式
-            document.getElementById("eq").innerHTML = eq;
-            // console.log(eq);
-        }
-    </script>
-</body>
-
-</html>
diff --git a/spaces/simonduerr/ProteinMPNN/af_backprop/alphafold/model/tf/__init__.py b/spaces/simonduerr/ProteinMPNN/af_backprop/alphafold/model/tf/__init__.py
deleted file mode 100644
index 6c520687f67754b0488690287f941854c8cf6133..0000000000000000000000000000000000000000
--- a/spaces/simonduerr/ProteinMPNN/af_backprop/alphafold/model/tf/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Copyright 2021 DeepMind Technologies Limited
-#
-# 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.
-"""Alphafold model TensorFlow code."""
diff --git a/spaces/simonduerr/diffdock/train.py b/spaces/simonduerr/diffdock/train.py
deleted file mode 100644
index b58e78854fe9908a1351b1dffde9ce7e9800ed79..0000000000000000000000000000000000000000
--- a/spaces/simonduerr/diffdock/train.py
+++ /dev/null
@@ -1,158 +0,0 @@
-import copy
-import math
-import os
-from functools import partial
-
-import wandb
-import torch
-torch.multiprocessing.set_sharing_strategy('file_system')
-
-import resource
-rlimit = resource.getrlimit(resource.RLIMIT_NOFILE)
-resource.setrlimit(resource.RLIMIT_NOFILE, (64000, rlimit[1]))
-
-import yaml
-
-from utils.diffusion_utils import t_to_sigma as t_to_sigma_compl
-from datasets.pdbbind import construct_loader
-from utils.parsing import parse_train_args
-from utils.training import train_epoch, test_epoch, loss_function, inference_epoch
-from utils.utils import save_yaml_file, get_optimizer_and_scheduler, get_model, ExponentialMovingAverage
-
-
-def train(args, model, optimizer, scheduler, ema_weights, train_loader, val_loader, t_to_sigma, run_dir):
-    best_val_loss = math.inf
-    best_val_inference_value = math.inf if args.inference_earlystop_goal == 'min' else 0
-    best_epoch = 0
-    best_val_inference_epoch = 0
-    loss_fn = partial(loss_function, tr_weight=args.tr_weight, rot_weight=args.rot_weight,
-                      tor_weight=args.tor_weight, no_torsion=args.no_torsion)
-
-    print("Starting training...")
-    for epoch in range(args.n_epochs):
-        if epoch % 5 == 0: print("Run name: ", args.run_name)
-        logs = {}
-        train_losses = train_epoch(model, train_loader, optimizer, device, t_to_sigma, loss_fn, ema_weights)
-        print("Epoch {}: Training loss {:.4f}  tr {:.4f}   rot {:.4f}   tor {:.4f}"
-              .format(epoch, train_losses['loss'], train_losses['tr_loss'], train_losses['rot_loss'],
-                      train_losses['tor_loss']))
-
-        ema_weights.store(model.parameters())
-        if args.use_ema: ema_weights.copy_to(model.parameters()) # load ema parameters into model for running validation and inference
-        val_losses = test_epoch(model, val_loader, device, t_to_sigma, loss_fn, args.test_sigma_intervals)
-        print("Epoch {}: Validation loss {:.4f}  tr {:.4f}   rot {:.4f}   tor {:.4f}"
-              .format(epoch, val_losses['loss'], val_losses['tr_loss'], val_losses['rot_loss'], val_losses['tor_loss']))
-
-        if args.val_inference_freq != None and (epoch + 1) % args.val_inference_freq == 0:
-            inf_metrics = inference_epoch(model, val_loader.dataset.complex_graphs[:args.num_inference_complexes], device, t_to_sigma, args)
-            print("Epoch {}: Val inference rmsds_lt2 {:.3f} rmsds_lt5 {:.3f}"
-                  .format(epoch, inf_metrics['rmsds_lt2'], inf_metrics['rmsds_lt5']))
-            logs.update({'valinf_' + k: v for k, v in inf_metrics.items()}, step=epoch + 1)
-
-        if not args.use_ema: ema_weights.copy_to(model.parameters())
-        ema_state_dict = copy.deepcopy(model.module.state_dict() if device.type == 'cuda' else model.state_dict())
-        ema_weights.restore(model.parameters())
-
-        if args.wandb:
-            logs.update({'train_' + k: v for k, v in train_losses.items()})
-            logs.update({'val_' + k: v for k, v in val_losses.items()})
-            logs['current_lr'] = optimizer.param_groups[0]['lr']
-            wandb.log(logs, step=epoch + 1)
-
-        state_dict = model.module.state_dict() if device.type == 'cuda' else model.state_dict()
-        if args.inference_earlystop_metric in logs.keys() and \
-                (args.inference_earlystop_goal == 'min' and logs[args.inference_earlystop_metric] <= best_val_inference_value or
-                 args.inference_earlystop_goal == 'max' and logs[args.inference_earlystop_metric] >= best_val_inference_value):
-            best_val_inference_value = logs[args.inference_earlystop_metric]
-            best_val_inference_epoch = epoch
-            torch.save(state_dict, os.path.join(run_dir, 'best_inference_epoch_model.pt'))
-            torch.save(ema_state_dict, os.path.join(run_dir, 'best_ema_inference_epoch_model.pt'))
-        if val_losses['loss'] <= best_val_loss:
-            best_val_loss = val_losses['loss']
-            best_epoch = epoch
-            torch.save(state_dict, os.path.join(run_dir, 'best_model.pt'))
-            torch.save(ema_state_dict, os.path.join(run_dir, 'best_ema_model.pt'))
-
-        if scheduler:
-            if args.val_inference_freq is not None:
-                scheduler.step(best_val_inference_value)
-            else:
-                scheduler.step(val_losses['loss'])
-
-        torch.save({
-            'epoch': epoch,
-            'model': state_dict,
-            'optimizer': optimizer.state_dict(),
-            'ema_weights': ema_weights.state_dict(),
-        }, os.path.join(run_dir, 'last_model.pt'))
-
-    print("Best Validation Loss {} on Epoch {}".format(best_val_loss, best_epoch))
-    print("Best inference metric {} on Epoch {}".format(best_val_inference_value, best_val_inference_epoch))
-
-
-def main_function():
-    args = parse_train_args()
-    if args.config:
-        config_dict = yaml.load(args.config, Loader=yaml.FullLoader)
-        arg_dict = args.__dict__
-        for key, value in config_dict.items():
-            if isinstance(value, list):
-                for v in value:
-                    arg_dict[key].append(v)
-            else:
-                arg_dict[key] = value
-        args.config = args.config.name
-    assert (args.inference_earlystop_goal == 'max' or args.inference_earlystop_goal == 'min')
-    if args.val_inference_freq is not None and args.scheduler is not None:
-        assert (args.scheduler_patience > args.val_inference_freq) # otherwise we will just stop training after args.scheduler_patience epochs
-    if args.cudnn_benchmark:
-        torch.backends.cudnn.benchmark = True
-
-    # construct loader
-    t_to_sigma = partial(t_to_sigma_compl, args=args)
-    train_loader, val_loader = construct_loader(args, t_to_sigma)
-
-    model = get_model(args, device, t_to_sigma=t_to_sigma)
-    optimizer, scheduler = get_optimizer_and_scheduler(args, model, scheduler_mode=args.inference_earlystop_goal if args.val_inference_freq is not None else 'min')
-    ema_weights = ExponentialMovingAverage(model.parameters(),decay=args.ema_rate)
-
-    if args.restart_dir:
-        try:
-            dict = torch.load(f'{args.restart_dir}/last_model.pt', map_location=torch.device('cpu'))
-            if args.restart_lr is not None: dict['optimizer']['param_groups'][0]['lr'] = args.restart_lr
-            optimizer.load_state_dict(dict['optimizer'])
-            model.module.load_state_dict(dict['model'], strict=True)
-            if hasattr(args, 'ema_rate'):
-                ema_weights.load_state_dict(dict['ema_weights'], device=device)
-            print("Restarting from epoch", dict['epoch'])
-        except Exception as e:
-            print("Exception", e)
-            dict = torch.load(f'{args.restart_dir}/best_model.pt', map_location=torch.device('cpu'))
-            model.module.load_state_dict(dict, strict=True)
-            print("Due to exception had to take the best epoch and no optimiser")
-
-    numel = sum([p.numel() for p in model.parameters()])
-    print('Model with', numel, 'parameters')
-
-    if args.wandb:
-        wandb.init(
-            entity='entity',
-            settings=wandb.Settings(start_method="fork"),
-            project=args.project,
-            name=args.run_name,
-            config=args
-        )
-        wandb.log({'numel': numel})
-
-    # record parameters
-    run_dir = os.path.join(args.log_dir, args.run_name)
-    yaml_file_name = os.path.join(run_dir, 'model_parameters.yml')
-    save_yaml_file(yaml_file_name, args.__dict__)
-    args.device = device
-
-    train(args, model, optimizer, scheduler, ema_weights, train_loader, val_loader, t_to_sigma, run_dir)
-
-
-if __name__ == '__main__':
-    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
-    main_function()
\ No newline at end of file
diff --git a/spaces/skf15963/summary/fengshen/examples/classification/finetune_classification_bart-base_afqmc.sh b/spaces/skf15963/summary/fengshen/examples/classification/finetune_classification_bart-base_afqmc.sh
deleted file mode 100644
index 2700d2ad3d6fca47238db033781905ac372b183a..0000000000000000000000000000000000000000
--- a/spaces/skf15963/summary/fengshen/examples/classification/finetune_classification_bart-base_afqmc.sh
+++ /dev/null
@@ -1,143 +0,0 @@
-#!/bin/bash
-#SBATCH --job-name=afqmc-bart-base # create a short name for your job
-#SBATCH --nodes=1 # node count
-#SBATCH --ntasks=2 # total number of tasks across all nodes
-#SBATCH --cpus-per-task=30 # cpu-cores per task (>1 if multi-threaded tasks)
-#SBATCH --gres=gpu:2 # number of gpus per node
-#SBATCH --mail-type=ALL # send email when job begins, ends or failed etc. 
-#SBATCH -o %x-%j.log # output and error file name (%x=job name, %j=job id)
-
-
-export TORCH_EXTENSIONS_DIR=/cognitive_comp/gaoxinyu/cache/torch_extendsions
-
-MODEL_NAME=bart-base
-
-TASK=afqmc
-TEXTA_NAME=sentence1
-TEXTB_NAME=sentence2
-LABEL_NAME=label
-ID_NAME=id
-
-
-BATCH_SIZE=8
-VAL_BATCH_SIZE=32
-ZERO_STAGE=1
-STRATEGY=deepspeed_stage_${ZERO_STAGE}
-
-DATA_DIR=/cognitive_comp/yangping/data/ChineseCLUE_DATA/${TASK}_public/
-PRETRAINED_MODEL_PATH=/cognitive_comp/gaoxinyu/pretrained_model/$MODEL_NAME/
-
-
-CHECKPOINT_PATH=/cognitive_comp/gaoxinyu/ln_model/finetune/ckpt/$TASK/
-DEFAULT_ROOT_DIR=/cognitive_comp/gaoxinyu/ln_model/finetune/${MODEL_NAME}-${TASK}
-OUTPUT_PATH=/cognitive_comp/gaoxinyu/ln_model/finetune/${MODEL_NAME}-${TASK}/predict.json
-
-
-config_json="./ds_config.${MODEL_NAME}.json"
-# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
-# reduce_bucket_size: hidden_size*hidden_size
-# stage3_prefetch_bucket_size: 0.9 * hidden_size * hidden_size
-# stage3_param_persistence_threshold: 10 * hidden_size
-
-cat <<EOT > $config_json
-{
-  "train_micro_batch_size_per_gpu": $BATCH_SIZE,
-  "steps_per_print": 100,
-  "gradient_clipping": 0.1,
-  "zero_optimization": {
-        "stage": ${ZERO_STAGE}
-    },
-  "optimizer": {
-    "type": "Adam",
-    "params": {
-      "lr": 1e-7,
-      "eps": 1e-12,
-      "weight_decay": 1e-2
-    }
-  },
-  "scheduler": {
-    "type": "WarmupLR",
-    "params":{
-      "warmup_min_lr": 1e-5,
-      "warmup_max_lr": 1e-4,
-      "warmup_num_steps": 400,
-      "warmup_type": "linear"
-    }
-  },
-  "zero_allow_untested_optimizer": false,
-  "fp16": {
-    "enabled": false,
-    "loss_scale": 0,
-    "loss_scale_window": 1000,
-    "hysteresis": 2,
-    "min_loss_scale": 1
-  },
-  "activation_checkpointing": {
-    "partition_activations": false,
-    "contiguous_memory_optimization": false
-  },
-  "wall_clock_breakdown": false
-}
-EOT
-
-export PL_DEEPSPEED_CONFIG_PATH=$config_json
-
-
-DATA_ARGS="\
-        --data_dir $DATA_DIR \
-        --train_data train.json \
-        --valid_data dev.json \
-        --test_data test.json \
-        --train_batchsize $BATCH_SIZE \
-        --valid_batchsize $VAL_BATCH_SIZE \
-        --max_length 64 \
-        --texta_name $TEXTA_NAME \
-        --textb_name $TEXTB_NAME \
-        --label_name $LABEL_NAME \
-        --id_name $ID_NAME \
-        "
-
-MODEL_ARGS="\
-        --learning_rate 1e-6 \
-        --weight_decay 1e-2 \
-        --warmup 0.01 \
-        --num_labels 2 \
-        "
-
-MODEL_CHECKPOINT_ARGS="\
-        --monitor val_acc \
-        --save_top_k 3 \
-        --mode max \
-        --every_n_train_steps 200 \
-        --save_weights_only True \
-        --dirpath $CHECKPOINT_PATH \
-        --filename model-{epoch:02d}-{val_acc:.4f} \
-        "
-
-
-TRAINER_ARGS="\
-        --max_epochs 67 \
-        --gpus 2 \
-        --num_nodes 1 \
-        --strategy $STRATEGY \
-        --gradient_clip_val 1.0 \
-        --check_val_every_n_epoch 1 \
-        --val_check_interval 1.0 \
-        --default_root_dir $DEFAULT_ROOT_DIR \
-        "
-
-options=" \
-        --pretrained_model_path $PRETRAINED_MODEL_PATH \
-        --output_save_path $OUTPUT_PATH \
-        $DATA_ARGS \
-        $MODEL_ARGS \
-        $MODEL_CHECKPOINT_ARGS \
-        $TRAINER_ARGS \
-        "
-
-DOCKER_PATH=/cognitive_comp/gaoxinyu/docker/pytorch21_06_py3_docker_image_v2.sif
-SCRIPT_PATH=/cognitive_comp/gaoxinyu/github/Fengshenbang-LM/fengshen/examples/classification/finetune_classification.py
-
-# python3 $SCRIPT_PATH $options
-srun singularity exec --nv -B /cognitive_comp/:/cognitive_comp/ $DOCKER_PATH python3 $SCRIPT_PATH $options
-
diff --git a/spaces/sriramelango/Social_Classification_Public/fairseq/fairseq/models/speech_to_text/convtransformer.py b/spaces/sriramelango/Social_Classification_Public/fairseq/fairseq/models/speech_to_text/convtransformer.py
deleted file mode 100644
index eba000d7b0826d2ecf5dc471156f8f8cc9f5e402..0000000000000000000000000000000000000000
--- a/spaces/sriramelango/Social_Classification_Public/fairseq/fairseq/models/speech_to_text/convtransformer.py
+++ /dev/null
@@ -1,448 +0,0 @@
-#!/usr/bin/env python3
-
-import logging
-import math
-from typing import Dict, List, Optional, Tuple
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from fairseq import checkpoint_utils, utils
-from fairseq.data.data_utils import lengths_to_padding_mask
-from fairseq.models import (
-    FairseqEncoder,
-    FairseqEncoderDecoderModel,
-    register_model,
-    register_model_architecture,
-)
-from fairseq.models.transformer import Embedding, TransformerDecoder
-from fairseq.modules import LayerNorm, PositionalEmbedding, TransformerEncoderLayer
-from torch import Tensor
-
-logger = logging.getLogger(__name__)
-
-
-@register_model("convtransformer")
-class ConvTransformerModel(FairseqEncoderDecoderModel):
-    """
-    Transformer-based Speech translation model from ESPNet-ST
-    https://arxiv.org/abs/2004.10234
-    """
-
-    def __init__(self, encoder, decoder):
-        super().__init__(encoder, decoder)
-
-    @staticmethod
-    def add_args(parser):
-        """Add model-specific arguments to the parser."""
-        parser.add_argument(
-            "--input-feat-per-channel",
-            type=int,
-            metavar="N",
-            help="encoder input dimension per input channel",
-        )
-        parser.add_argument(
-            "--activation-fn",
-            choices=utils.get_available_activation_fns(),
-            help="activation function to use",
-        )
-        parser.add_argument(
-            "--dropout", type=float, metavar="D", help="dropout probability"
-        )
-        parser.add_argument(
-            "--attention-dropout",
-            type=float,
-            metavar="D",
-            help="dropout probability for attention weights",
-        )
-        parser.add_argument(
-            "--activation-dropout",
-            "--relu-dropout",
-            type=float,
-            metavar="D",
-            help="dropout probability after activation in FFN.",
-        )
-        parser.add_argument(
-            "--encoder-embed-dim",
-            type=int,
-            metavar="N",
-            help="encoder embedding dimension",
-        )
-        parser.add_argument(
-            "--encoder-ffn-embed-dim",
-            type=int,
-            metavar="N",
-            help="encoder embedding dimension for FFN",
-        )
-        parser.add_argument(
-            "--encoder-layers", type=int, metavar="N", help="num encoder layers"
-        )
-        parser.add_argument(
-            "--encoder-attention-heads",
-            type=int,
-            metavar="N",
-            help="num encoder attention heads",
-        )
-        parser.add_argument(
-            "--encoder-normalize-before",
-            action="store_true",
-            help="apply layernorm before each encoder block",
-        )
-        parser.add_argument(
-            "--decoder-embed-dim",
-            type=int,
-            metavar="N",
-            help="decoder embedding dimension",
-        )
-        parser.add_argument(
-            "--decoder-ffn-embed-dim",
-            type=int,
-            metavar="N",
-            help="decoder embedding dimension for FFN",
-        )
-        parser.add_argument(
-            "--decoder-layers", type=int, metavar="N", help="num decoder layers"
-        )
-        parser.add_argument(
-            "--decoder-attention-heads",
-            type=int,
-            metavar="N",
-            help="num decoder attention heads",
-        )
-        parser.add_argument(
-            "--decoder-normalize-before",
-            action="store_true",
-            help="apply layernorm before each decoder block",
-        )
-        parser.add_argument(
-            "--decoder-output-dim",
-            type=int,
-            metavar="N",
-            help="decoder output dimension (extra linear layer if different from decoder embed dim)",
-        )
-        parser.add_argument(
-            "--share-decoder-input-output-embed",
-            action="store_true",
-            help="share decoder input and output embeddings",
-        )
-        parser.add_argument(
-            "--layernorm-embedding",
-            action="store_true",
-            help="add layernorm to embedding",
-        )
-        parser.add_argument(
-            "--no-scale-embedding",
-            action="store_true",
-            help="if True, dont scale embeddings",
-        )
-        parser.add_argument(
-            "--load-pretrained-encoder-from",
-            type=str,
-            metavar="STR",
-            help="model to take encoder weights from (for initialization)",
-        )
-        parser.add_argument(
-            "--load-pretrained-decoder-from",
-            type=str,
-            metavar="STR",
-            help="model to take decoder weights from (for initialization)",
-        )
-        parser.add_argument(
-            "--conv-out-channels",
-            type=int,
-            metavar="INT",
-            help="the number of output channels of conv layer",
-        )
-
-    @classmethod
-    def build_encoder(cls, args):
-        encoder = ConvTransformerEncoder(args)
-        if getattr(args, "load_pretrained_encoder_from", None):
-            encoder = checkpoint_utils.load_pretrained_component_from_model(
-                component=encoder, checkpoint=args.load_pretrained_encoder_from
-            )
-        return encoder
-
-    @classmethod
-    def build_decoder(cls, args, task, embed_tokens):
-        decoder = TransformerDecoderNoExtra(args, task.target_dictionary, embed_tokens)
-        if getattr(args, "load_pretrained_decoder_from", None):
-            decoder = checkpoint_utils.load_pretrained_component_from_model(
-                component=decoder, checkpoint=args.load_pretrained_decoder_from
-            )
-        return decoder
-
-    @classmethod
-    def build_model(cls, args, task):
-        """Build a new model instance."""
-
-        # make sure all arguments are present in older models
-        base_architecture(args)
-
-        def build_embedding(dictionary, embed_dim):
-            num_embeddings = len(dictionary)
-            padding_idx = dictionary.pad()
-            return Embedding(num_embeddings, embed_dim, padding_idx)
-
-        decoder_embed_tokens = build_embedding(
-            task.target_dictionary, args.decoder_embed_dim
-        )
-        encoder = cls.build_encoder(args)
-        decoder = cls.build_decoder(args, task, decoder_embed_tokens)
-        return cls(encoder, decoder)
-
-    @staticmethod
-    @torch.jit.unused
-    def set_batch_first(lprobs):
-        lprobs.batch_first = True
-
-    def get_normalized_probs(
-        self,
-        net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],
-        log_probs: bool,
-        sample: Optional[Dict[str, Tensor]] = None,
-    ):
-        # net_output['encoder_out'] is a (B, T, D) tensor
-        lprobs = self.get_normalized_probs_scriptable(net_output, log_probs, sample)
-        if self.training:
-            self.set_batch_first(lprobs)
-        return lprobs
-
-    def output_layout(self):
-        return "BTD"
-
-    """
-    The forward method inherited from the base class has a **kwargs argument in
-    its input, which is not supported in torchscript. This method overrites the forward
-    method definition without **kwargs.
-    """
-
-    def forward(self, src_tokens, src_lengths, prev_output_tokens):
-        encoder_out = self.encoder(src_tokens=src_tokens, src_lengths=src_lengths)
-        decoder_out = self.decoder(
-            prev_output_tokens=prev_output_tokens, encoder_out=encoder_out
-        )
-        return decoder_out
-
-
-class ConvTransformerEncoder(FairseqEncoder):
-    """Conv + Transformer encoder"""
-
-    def __init__(self, args):
-        """Construct an Encoder object."""
-        super().__init__(None)
-
-        self.dropout = args.dropout
-        self.embed_scale = (
-            1.0 if args.no_scale_embedding else math.sqrt(args.encoder_embed_dim)
-        )
-        self.padding_idx = 1
-        self.in_channels = 1
-        self.input_dim = args.input_feat_per_channel
-        self.conv = torch.nn.Sequential(
-            torch.nn.Conv2d(1, args.conv_out_channels, 3, stride=2, padding=3 // 2),
-            torch.nn.ReLU(),
-            torch.nn.Conv2d(
-                args.conv_out_channels,
-                args.conv_out_channels,
-                3,
-                stride=2,
-                padding=3 // 2,
-            ),
-            torch.nn.ReLU(),
-        )
-        transformer_input_dim = self.infer_conv_output_dim(
-            self.in_channels, self.input_dim, args.conv_out_channels
-        )
-        self.out = torch.nn.Linear(transformer_input_dim, args.encoder_embed_dim)
-        self.embed_positions = PositionalEmbedding(
-            args.max_source_positions,
-            args.encoder_embed_dim,
-            self.padding_idx,
-            learned=False,
-        )
-
-        self.transformer_layers = nn.ModuleList([])
-        self.transformer_layers.extend(
-            [TransformerEncoderLayer(args) for i in range(args.encoder_layers)]
-        )
-        if args.encoder_normalize_before:
-            self.layer_norm = LayerNorm(args.encoder_embed_dim)
-        else:
-            self.layer_norm = None
-
-    def pooling_ratio(self):
-        return 4
-
-    def infer_conv_output_dim(self, in_channels, input_dim, out_channels):
-        sample_seq_len = 200
-        sample_bsz = 10
-        x = torch.randn(sample_bsz, in_channels, sample_seq_len, input_dim)
-        x = torch.nn.Conv2d(1, out_channels, 3, stride=2, padding=3 // 2)(x)
-        x = torch.nn.Conv2d(out_channels, out_channels, 3, stride=2, padding=3 // 2)(x)
-        x = x.transpose(1, 2)
-        mb, seq = x.size()[:2]
-        return x.contiguous().view(mb, seq, -1).size(-1)
-
-    def forward(self, src_tokens, src_lengths):
-        """Encode input sequence.
-        :param torch.Tensor xs: input tensor
-        :param torch.Tensor masks: input mask
-        :return: position embedded tensor and mask
-        :rtype Tuple[torch.Tensor, torch.Tensor]:
-        """
-        bsz, max_seq_len, _ = src_tokens.size()
-        x = (
-            src_tokens.view(bsz, max_seq_len, self.in_channels, self.input_dim)
-            .transpose(1, 2)
-            .contiguous()
-        )
-        x = self.conv(x)
-        bsz, _, output_seq_len, _ = x.size()
-        x = x.transpose(1, 2).transpose(0, 1).contiguous().view(output_seq_len, bsz, -1)
-        x = self.out(x)
-        x = self.embed_scale * x
-
-        subsampling_factor = int(max_seq_len * 1.0 / output_seq_len + 0.5)
-        input_len_0 = (src_lengths.float() / subsampling_factor).ceil().long()
-        input_len_1 = x.size(0) * torch.ones([src_lengths.size(0)]).long().to(
-            input_len_0.device
-        )
-        input_lengths = torch.min(input_len_0, input_len_1)
-
-        encoder_padding_mask = lengths_to_padding_mask(input_lengths)
-
-        positions = self.embed_positions(encoder_padding_mask).transpose(0, 1)
-        x += positions
-        x = F.dropout(x, p=self.dropout, training=self.training)
-
-        for layer in self.transformer_layers:
-            x = layer(x, encoder_padding_mask)
-
-        if not encoder_padding_mask.any():
-            maybe_encoder_padding_mask = None
-        else:
-            maybe_encoder_padding_mask = encoder_padding_mask
-
-        return {
-            "encoder_out": [x],
-            "encoder_padding_mask": [maybe_encoder_padding_mask]
-            if maybe_encoder_padding_mask is not None
-            else [],
-            "encoder_embedding": [],
-            "encoder_states": [],
-            "src_tokens": [],
-            "src_lengths": [],
-        }
-
-    @torch.jit.export
-    def reorder_encoder_out(self, encoder_out: Dict[str, List[Tensor]], new_order):
-        """
-        Reorder encoder output according to *new_order*.
-
-        Args:
-            encoder_out: output from the ``forward()`` method
-            new_order (LongTensor): desired order
-
-        Returns:
-            *encoder_out* rearranged according to *new_order*
-        """
-        new_encoder_out = [encoder_out["encoder_out"][0].index_select(1, new_order)]
-        if len(encoder_out["encoder_padding_mask"]) == 0:
-            new_encoder_padding_mask = []
-        else:
-            new_encoder_padding_mask = [
-                (encoder_out["encoder_padding_mask"][0]).index_select(0, new_order)
-            ]
-        if len(encoder_out["encoder_embedding"]) == 0:
-            new_encoder_embedding = []
-        else:
-            new_encoder_embedding = [
-                (encoder_out["encoder_embedding"][0]).index_select(0, new_order)
-            ]
-        encoder_states = encoder_out["encoder_states"]
-        if len(encoder_states) > 0:
-            for idx, state in enumerate(encoder_states):
-                encoder_states[idx] = state.index_select(1, new_order)
-
-        return {
-            "encoder_out": new_encoder_out,
-            "encoder_padding_mask": new_encoder_padding_mask,
-            "encoder_embedding": new_encoder_embedding,
-            "encoder_states": encoder_states,
-            "src_tokens": [],
-            "src_lengths": [],
-        }
-
-
-class TransformerDecoderNoExtra(TransformerDecoder):
-    def extract_features(
-        self,
-        prev_output_tokens,
-        encoder_out: Optional[Dict[str, List[Tensor]]],
-        incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
-        full_context_alignment: bool = False,
-        alignment_layer: Optional[int] = None,
-        alignment_heads: Optional[int] = None,
-    ):
-        # call scriptable method from parent class
-        x, _ = self.extract_features_scriptable(
-            prev_output_tokens,
-            encoder_out,
-            incremental_state,
-            full_context_alignment,
-            alignment_layer,
-            alignment_heads,
-        )
-        return x, None
-
-
-@register_model_architecture(model_name="convtransformer", arch_name="convtransformer")
-def base_architecture(args):
-    args.input_feat_per_channel = getattr(args, "input_feat_per_channel", 80)
-    args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512)
-    args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048)
-    args.encoder_layers = getattr(args, "encoder_layers", 6)
-    args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8)
-    args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False)
-    args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim)
-    args.decoder_ffn_embed_dim = getattr(
-        args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim
-    )
-    args.decoder_layers = getattr(args, "decoder_layers", 6)
-    args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8)
-    args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False)
-    args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False)
-    args.attention_dropout = getattr(args, "attention_dropout", 0.0)
-    args.activation_dropout = getattr(args, "activation_dropout", 0.0)
-    args.activation_fn = getattr(args, "activation_fn", "relu")
-    args.dropout = getattr(args, "dropout", 0.1)
-    args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None)
-    args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0)
-    args.share_decoder_input_output_embed = getattr(
-        args, "share_decoder_input_output_embed", False
-    )
-    args.no_token_positional_embeddings = getattr(
-        args, "no_token_positional_embeddings", False
-    )
-    args.adaptive_input = getattr(args, "adaptive_input", False)
-    args.decoder_layerdrop = getattr(args, "decoder_layerdrop", 0.0)
-
-    args.decoder_output_dim = getattr(
-        args, "decoder_output_dim", args.decoder_embed_dim
-    )
-    args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim)
-    args.no_scale_embedding = getattr(args, "no_scale_embedding", False)
-    args.quant_noise_pq = getattr(args, "quant_noise_pq", 0)
-    args.max_source_positions = getattr(args, "max_source_positions", 3000)
-    args.max_target_positions = getattr(args, "max_target_positions", 1024)
-    args.tie_adaptive_weights = getattr(args, "tie_adaptive_weights", False)
-    args.conv_out_channels = getattr(args, "conv_out_channels", args.encoder_embed_dim)
-
-
-@register_model_architecture("convtransformer", "convtransformer_espnet")
-def convtransformer_espnet(args):
-    args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 256)
-    args.encoder_layers = getattr(args, "encoder_layers", 12)
-    args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4)
-    args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4)
diff --git a/spaces/stomexserde/gpt4-ui/Examples/Cymatics 2020 Melody Collection WAV [free [UPD]].md b/spaces/stomexserde/gpt4-ui/Examples/Cymatics 2020 Melody Collection WAV [free [UPD]].md
deleted file mode 100644
index 1dbb44f8ab00fca1cb9407a0a1eda17150ae6fe9..0000000000000000000000000000000000000000
--- a/spaces/stomexserde/gpt4-ui/Examples/Cymatics 2020 Melody Collection WAV [free [UPD]].md	
+++ /dev/null
@@ -1,26 +0,0 @@
-
-<h1>Cymatics 2020 Melody Collection WAV: A Free Download for Music Producers</h1>
-<p>If you are looking for some fresh and inspiring melodies to spice up your music production, you might want to check out the Cymatics 2020 Melody Collection WAV. This is a free download that contains over 100 high-quality WAV files of various genres and styles, such as trap, hip hop, pop, EDM, and more.</p>
-<p>The Cymatics 2020 Melody Collection WAV is a great resource for music producers who want to save time and get inspired by professional sounds. You can use these melodies as they are, or tweak them to suit your own taste and style. You can also mix and match different melodies to create unique combinations and variations.</p>
-<h2>Cymatics 2020 Melody Collection WAV [FREE]</h2><br /><p><b><b>DOWNLOAD</b> &#10145; <a href="https://urlgoal.com/2uIbVo">https://urlgoal.com/2uIbVo</a></b></p><br /><br />
-<p>The best part is that the Cymatics 2020 Melody Collection WAV is completely free to download. All you need to do is visit the Cymatics website and enter your email address to get access to the download link. You can then use these melodies in your own projects without any limitations or restrictions.</p>
-<p>So what are you waiting for? Download the Cymatics 2020 Melody Collection WAV today and unleash your creativity with these amazing sounds.</p>
-
-<p>How to Use the Cymatics 2020 Melody Collection WAV</p>
-<p>Using the Cymatics 2020 Melody Collection WAV is very easy and straightforward. All you need to do is drag and drop the WAV files into your favorite DAW (digital audio workstation) and start making music. You can also import the WAV files into any sampler or plugin that supports WAV format.</p>
-<p>The Cymatics 2020 Melody Collection WAV is compatible with any DAW or software that can handle WAV files, such as FL Studio, Ableton Live, Logic Pro, Cubase, Pro Tools, and more. You can also use these melodies with any hardware or software synthesizer, such as Serum, Massive, Sylenth1, Omnisphere, and more.</p>
-<p>The Cymatics 2020 Melody Collection WAV is designed to give you maximum flexibility and creativity. You can adjust the tempo, pitch, key, and volume of each melody to fit your project. You can also layer, chop, reverse, or manipulate the melodies in any way you want. The possibilities are endless.</p>
-<p></p>
-
-<p>Why You Should Download the Cymatics 2020 Melody Collection WAV</p>
-<p>The Cymatics 2020 Melody Collection WAV is a must-have for any music producer who wants to level up their game and make better music. Here are some of the benefits of downloading this free pack:</p>
-<ul>
-<li>You get access to over 100 high-quality melodies that are ready to use in your projects.</li>
-<li>You get to explore different genres and styles of music, such as trap, hip hop, pop, EDM, and more.</li>
-<li>You get to learn from the experts and see how they craft their melodies.</li>
-<li>You get to save time and avoid the hassle of creating melodies from scratch.</li>
-<li>You get to have fun and experiment with different sounds and combinations.</li>
-</ul>
-<p>The Cymatics 2020 Melody Collection WAV is a no-brainer for any music producer who wants to improve their skills and make more music. Download it today and see for yourself how it can transform your music production.</p> e93f5a0c3f<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/stomexserde/gpt4-ui/Examples/Dds 7.2 Dongle 46.md b/spaces/stomexserde/gpt4-ui/Examples/Dds 7.2 Dongle 46.md
deleted file mode 100644
index afdecdb4865432ecbce7371e159aed7e5960390c..0000000000000000000000000000000000000000
--- a/spaces/stomexserde/gpt4-ui/Examples/Dds 7.2 Dongle 46.md	
+++ /dev/null
@@ -1,30 +0,0 @@
-
-<h1>How to Use Dds 7.2 Dongle 46 for Vibrio M and Lubri Devices</h1>
-<p>Dds 7.2 dongle 46 is a licensed version of the Dds software that allows you to create and view data from Adash Vibrio M and Lubri devices. Vibrio M is a vibration meter and analyzer, while Lubri is a bearing lubrication monitor. With Dds 7.2 dongle 46, you can perform various measurements, such as vibration spectrum, time signal, bearing condition, temperature, and more.</p>
-<h2>Dds 7.2 dongle 46</h2><br /><p><b><b>DOWNLOAD</b> &#8250;&#8250;&#8250;&#8250;&#8250; <a href="https://urlgoal.com/2uIcex">https://urlgoal.com/2uIcex</a></b></p><br /><br />
-<p>To use Dds 7.2 dongle 46, you need to install the Dds software on your computer and connect the dongle key to a USB port. The dongle key contains the license information that enables you to run the Dds Basic or Dds Full version, depending on your purchase. The Dds software can be downloaded from <a href="https://adash.com/downloads/adash-software/dds-versions">Adash website</a>.</p>
-<p>Once you have installed the Dds software and connected the dongle key, you can connect your Vibrio M or Lubri device to your computer via USB cable or Bluetooth. You can then create a new database or open an existing one in the Dds software. A database is a collection of data cells that store your measurement results. You can organize your data cells into a tree structure according to your preferences.</p>
-<p>To create a new data cell, you need to select the measurement type from the menu bar. For example, if you want to measure vibration spectrum, you need to select Spectrum > New Spectrum Cell. You can then configure the measurement parameters, such as frequency range, resolution, averaging, etc. You can also select the input channel and device type from the drop-down menus.</p>
-<p>After setting up the measurement parameters, you can start the measurement by clicking on the Start button. The Dds software will communicate with your Vibrio M or Lubri device and display the measurement results in real time. You can also save the measurement results to your database by clicking on the Save button.</p>
-<p>You can view your saved data cells by selecting them from the tree structure. You can also edit, delete, copy, move, or export your data cells as needed. The Dds software provides various tools for analyzing and displaying your data, such as zooming, cursors, markers, filters, trends, reports, etc.</p>
-<p>Dds 7.2 dongle 46 is a powerful and versatile tool for working with Vibrio M and Lubri devices. It allows you to perform various measurements and analyses with ease and accuracy. If you need more information or support, you can visit <a href="https://adash.com/support/">Adash support page</a> or contact them directly.</p>
-
-<p>In this section, we will show you some examples of how to use Dds 7.2 dongle 46 for Vibrio M and Lubri devices. We will demonstrate how to measure and analyze vibration spectrum, bearing condition, and lubrication status.</p>
-<p></p>
-<h2>How to Measure and Analyze Vibration Spectrum</h2>
-<p>Vibration spectrum is a graphical representation of the vibration signal in the frequency domain. It shows the amplitude and frequency of the vibration components that make up the signal. Vibration spectrum can be used to identify the sources and causes of vibration, such as imbalance, misalignment, looseness, resonance, etc.</p>
-<p>To measure vibration spectrum with Vibrio M and Dds 7.2 dongle 46, you need to attach an accelerometer to the point of interest on the machine or structure. You can use a magnetic base, a stud, or a glue to mount the accelerometer. You also need to connect the accelerometer cable to the Vibrio M device.</p>
-<p>Next, you need to create a new spectrum cell in the Dds software and configure the measurement parameters. You can select the frequency range, resolution, averaging, windowing, etc. according to your needs. You can also select the input channel and device type from the drop-down menus.</p>
-<p>Then, you can start the measurement by clicking on the Start button. The Dds software will communicate with the Vibrio M device and display the vibration spectrum in real time. You can also save the spectrum to your database by clicking on the Save button.</p>
-<p>To analyze the vibration spectrum, you can use various tools in the Dds software, such as zooming, cursors, markers, filters, etc. You can also compare different spectra by using the overlay or waterfall functions. You can also generate a report or export the spectrum as an image or a text file.</p>
-<h2>How to Measure and Analyze Bearing Condition</h2>
-<p>Bearing condition is a numerical indicator of the health and performance of a rolling element bearing. It is based on the analysis of high-frequency vibration signals that are generated by defects or damage in the bearing components. Bearing condition can be used to detect and diagnose bearing faults, such as spalling, pitting, cracking, etc.</p>
-<p>To measure bearing condition with Lubri and Dds 7.2 dongle 46, you need to attach an accelerometer to the bearing housing or near the bearing location. You can use a magnetic base, a stud, or a glue to mount the accelerometer. You also need to connect the accelerometer cable to the Lubri device.</p>
-<p>Next, you need to create a new bearing cell in the Dds software and configure the measurement parameters. You can select the bearing type (ball or roller), number of elements (balls or rollers), diameter of elements (mm), pitch diameter (mm), contact angle (degrees), and rotational speed (rpm). You can also select the input channel and device type from the drop-down menus.</p>
-<p>Then, you can start the measurement by clicking on the Start button. The Dds software will communicate with the Lubri device and display the bearing condition in real time. You can also save the bearing condition to your database by clicking on the Save button.</p>
-<p>To analyze the bearing condition, you can use various tools in the Dds software, such as zooming, cursors, markers, filters, etc. You can also compare different bearing conditions by using the overlay or trend functions. You can also generate a report or export the bearing condition as an image or a text file.</p>
-<h2>How to Measure and Analyze Lubrication Status</h2>
-<p>Lubrication status is a numerical indicator of the quality and quantity of lubricant in a rolling element bearing. It is based on the analysis of low-frequency vibration signals that are affected by friction and lubrication conditions in the bearing. Lubrication status can be used to monitor and optimize lubrication practices, such as greasing intervals and amounts.</p>
-<p>To measure lubrication status with Lubri and Dds 7.2 dongle 46, you need to attach an accelerometer to</p> 81aa517590<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/stomexserde/gpt4-ui/Examples/Dozen Please WAV.md b/spaces/stomexserde/gpt4-ui/Examples/Dozen Please WAV.md
deleted file mode 100644
index 6f62811f33a1e7ec0681280d8a401a55a50c3473..0000000000000000000000000000000000000000
--- a/spaces/stomexserde/gpt4-ui/Examples/Dozen Please WAV.md	
+++ /dev/null
@@ -1,18 +0,0 @@
-
-<h1>Dozen Please WAV: The Ultimate Sound Library for Music Producers</h1>
-<p>If you are looking for high-quality, royalty-free sounds to spice up your music production, look no further than Dozen Please WAV. This sound library contains over 12,000 samples and loops in various genres, styles and moods. Whether you need drums, bass, synths, guitars, vocals, effects or anything else, Dozen Please WAV has it all.</p>
-<p>Dozen Please WAV is compatible with any DAW or sampler that supports WAV format. You can easily drag and drop the files into your project and start creating your masterpiece. You can also mix and match the sounds from different categories to create your own unique combinations. Dozen Please WAV gives you unlimited creative possibilities.</p>
-<h2>Dozen Please WAV</h2><br /><p><b><b>DOWNLOAD</b> &mdash; <a href="https://urlgoal.com/2uI6EY">https://urlgoal.com/2uI6EY</a></b></p><br /><br />
-<p>Dozen Please WAV is more than just a sound library. It is also a community of music producers who share their tips, tricks and feedback on the sounds. You can join the Dozen Please WAV Discord server and connect with other users, get exclusive offers and updates, and participate in contests and challenges. You can also follow Dozen Please WAV on social media and YouTube to get inspired by the tutorials and demos.</p>
-<p>Dozen Please WAV is the ultimate sound library for music producers who want to level up their game. It is affordable, versatile and easy to use. You can get instant access to Dozen Please WAV by visiting their website and downloading the files. You can also get a free sample pack by signing up for their newsletter. Don't miss this opportunity to get your hands on Dozen Please WAV today.</p>
-
-<p>Dozen Please WAV is not just a sound library, it is also a learning resource. You can learn from the experts who created the sounds and discover how they achieved their signature sound. You can also learn from the tutorials and demos that show you how to use the sounds in different genres and styles. Dozen Please WAV will help you improve your skills and knowledge as a music producer.</p>
-<p>Dozen Please WAV is also a great way to support independent artists and producers. By purchasing Dozen Please WAV, you are supporting the creators who put their passion and hard work into making the sounds. You are also supporting the community of music producers who use and enjoy Dozen Please WAV. You are part of a movement that values quality, creativity and diversity in music production.</p>
-<p>Dozen Please WAV is more than just a sound library, it is a lifestyle. It is for music producers who want to express themselves through their music and share it with the world. It is for music producers who want to have fun and experiment with new sounds and genres. It is for music producers who want to make their dreams come true. Dozen Please WAV is for you.</p>
-<p></p>
-
-<p>Dozen Please WAV is the sound library that you need to take your music production to the next level. It has everything you need to create amazing music in any genre and style. It is easy to use, affordable and reliable. It is also a community of music producers who support each other and share their passion for music. Dozen Please WAV is the ultimate sound library for music producers.</p>
-<p>Don't wait any longer and get your copy of Dozen Please WAV today. You will not regret it. You will be amazed by the quality and variety of the sounds. You will be inspired by the possibilities and opportunities that Dozen Please WAV offers you. You will be proud of the music that you create with Dozen Please WAV.</p>
-<p>Dozen Please WAV is the best investment that you can make for your music production career. It will help you achieve your goals and dreams as a music producer. It will help you stand out from the crowd and impress your audience. It will help you have fun and enjoy your music production journey. Dozen Please WAV is the sound library that you deserve.</p> cec2833e83<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/stomexserde/gpt4-ui/Examples/Fito Olivares 40 Exitos Vol 1 Rar Hit.md b/spaces/stomexserde/gpt4-ui/Examples/Fito Olivares 40 Exitos Vol 1 Rar Hit.md
deleted file mode 100644
index ddff00d413ca9d5a0b587dc65b27689dd9eed743..0000000000000000000000000000000000000000
--- a/spaces/stomexserde/gpt4-ui/Examples/Fito Olivares 40 Exitos Vol 1 Rar Hit.md	
+++ /dev/null
@@ -1,33 +0,0 @@
-
-<h1>Remembering Fito Olivares: The King of Cumbia</h1>
-<p>Fito Olivares was a Mexican cumbia musician who passed away on March 17, 2023. He was known for his catchy songs and energetic performances that made people dance and enjoy life. He had a long and successful career, releasing more than 40 albums and earning several awards and recognitions.</p>
-<p>In this article, we will review some of his most popular songs and albums, as well as his legacy and influence on the cumbia genre. If you are a fan of Fito Olivares, or if you want to discover his music, this article is for you.</p>
-<h2>Fito Olivares 40 Exitos Vol 1 Rar Hit</h2><br /><p><b><b>Download</b> &#10002; <a href="https://urlgoal.com/2uI6zV">https://urlgoal.com/2uI6zV</a></b></p><br /><br />
-<h2>Who was Fito Olivares?</h2>
-<p>Fito Olivares was born on April 19, 1947, in Rechinadores, Tamaulipas. He was the son of María Cristina Olivares and Mucio Olivares. He learned to play the saxophone at a young age, thanks to his father who bought him one. He also learned to play the guitar, the accordion, and the keyboard.</p>
-<p>He started his musical career in the 1960s, playing with various bands in Mexico and the United States. In 1977, he formed his own band, Fito Olivares y su Grupo (later renamed Fito Olivares y la Pura Sabrosura), with his brothers Javier and Jaime. They moved to Houston, Texas, where they established their base and gained popularity among the Hispanic community.</p>
-<h2>What were his most famous songs and albums?</h2>
-<p>Fito Olivares had a distinctive style of cumbia, mixing traditional elements with modern influences. He used synthesizers, electric guitars, brass instruments, and percussion to create a lively and festive sound. His lyrics were often humorous and playful, talking about love, parties, dancing, and everyday situations.</p>
-<p>Some of his most famous songs include:</p>
-<ul>
-<li>"Juana la Cubana" (1987), a song about a Cuban woman who loves to dance cumbia.</li>
-<li>"La Gallina" (1988), a song about a chicken that escapes from its owner and causes trouble in the neighborhood.</li>
-<li>"La Cobra" (1989), a song about a woman who is compared to a venomous snake.</li>
-<li>"El Colesterol" (1990), a song about a man who suffers from high cholesterol and has to change his diet.</li>
-<li>"Aguita de Melon" (1991), a song about a refreshing drink made with watermelon juice.</li>
-<li>"La Negra Catalina" (1992), a song about a dark-skinned woman who is admired by many men.</li>
-<li>"Cumbia Caliente" (1993), a song that celebrates the heat and passion of cumbia music.</li>
-</ul>
-<p>Some of his most successful albums include:</p>
-<ul>
-<li><em>Fito Olivares y su Grupo</em> (1980), his debut album that introduced his unique style of cumbia.</li>
-<li><em>La Sabrosura</em> (1987), his breakthrough album that featured "Juana la Cubana" and other hits.</li>
-<li><em>40 Exitos Vol. 1</em> (1994), a compilation album that included some of his best songs from his previous albums.</li>
-<li><em>40 Exitos Vol. 2</em> (1995), another compilation album that complemented the first volume.</li>
-<li><em>Grandes Exitos</em> (2003), a collection of his most popular songs remastered and enhanced with new arrangements.</li>
-</ul>
-<h2>What was his legacy and influence?</h2>
-<p>Fito Olivares was one of the most influential cumbia artists of all time. He helped popularize cumbia music in Mexico and the United States, as well as in other countries such as Colombia, Peru, Argentina, and Spain. His songs have been covered by many artists from different genres, such as rock, pop, salsa, reggaeton, hip hop, and electronic music.</p>
-<p>He was also an inspiration for many young musicians who followed his footsteps and created their own versions of cumbia. Some of them include Celso Piña, Los Ánge</p> 7196e7f11a<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/sub314xxl/MetaGPT/tests/metagpt/roles/test_qa_engineer.py b/spaces/sub314xxl/MetaGPT/tests/metagpt/roles/test_qa_engineer.py
deleted file mode 100644
index 8fd7c0373835d8793fb910ab3131f0da772c0d63..0000000000000000000000000000000000000000
--- a/spaces/sub314xxl/MetaGPT/tests/metagpt/roles/test_qa_engineer.py
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-@Time    : 2023/5/12 12:01
-@Author  : alexanderwu
-@File    : test_qa_engineer.py
-"""
diff --git a/spaces/sub314xxl/MetaGPT/tests/metagpt/tools/test_sd_tool.py b/spaces/sub314xxl/MetaGPT/tests/metagpt/tools/test_sd_tool.py
deleted file mode 100644
index 89c97f5e8028cf63a1fdbef3b8140ab6d870a5b8..0000000000000000000000000000000000000000
--- a/spaces/sub314xxl/MetaGPT/tests/metagpt/tools/test_sd_tool.py
+++ /dev/null
@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Date    : 2023/7/22 02:40
-# @Author  : stellahong (stellahong@fuzhi.ai)
-#
-import os
-
-from metagpt.config import CONFIG
-from metagpt.tools.sd_engine import SDEngine
-
-
-def test_sd_engine_init():
-    sd_engine = SDEngine()
-    assert sd_engine.payload["seed"] == -1
-
-
-def test_sd_engine_generate_prompt():
-    sd_engine = SDEngine()
-    sd_engine.construct_payload(prompt="test")
-    assert sd_engine.payload["prompt"] == "test"
-
-
-async def test_sd_engine_run_t2i():
-    sd_engine = SDEngine()
-    await sd_engine.run_t2i(prompts=["test"])
-    img_path = CONFIG.workspace / "resources" / "SD_Output" / "output_0.png"
-    assert os.path.exists(img_path) == True
diff --git a/spaces/sunnyzhifei/ChatGPTOnline/modules/utils.py b/spaces/sunnyzhifei/ChatGPTOnline/modules/utils.py
deleted file mode 100644
index 23f47d688d9690c6c68ccacc765108ce68d62b76..0000000000000000000000000000000000000000
--- a/spaces/sunnyzhifei/ChatGPTOnline/modules/utils.py
+++ /dev/null
@@ -1,536 +0,0 @@
-# -*- coding:utf-8 -*-
-from __future__ import annotations
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Tuple, Type
-import logging
-import json
-import os
-import datetime
-import hashlib
-import csv
-import requests
-import re
-import html
-import sys
-import subprocess
-
-import gradio as gr
-from pypinyin import lazy_pinyin
-import tiktoken
-import mdtex2html
-from markdown import markdown
-from pygments import highlight
-from pygments.lexers import get_lexer_by_name
-from pygments.formatters import HtmlFormatter
-import pandas as pd
-
-from modules.presets import *
-from . import shared
-from modules.config import retrieve_proxy
-
-if TYPE_CHECKING:
-    from typing import TypedDict
-
-    class DataframeData(TypedDict):
-        headers: List[str]
-        data: List[List[str | int | bool]]
-
-
-def count_token(message):
-    encoding = tiktoken.get_encoding("cl100k_base")
-    input_str = f"role: {message['role']}, content: {message['content']}"
-    length = len(encoding.encode(input_str))
-    return length
-
-
-def markdown_to_html_with_syntax_highlight(md_str):
-    def replacer(match):
-        lang = match.group(1) or "text"
-        code = match.group(2)
-
-        try:
-            lexer = get_lexer_by_name(lang, stripall=True)
-        except ValueError:
-            lexer = get_lexer_by_name("text", stripall=True)
-
-        formatter = HtmlFormatter()
-        highlighted_code = highlight(code, lexer, formatter)
-
-        return f'<pre><code class="{lang}">{highlighted_code}</code></pre>'
-
-    code_block_pattern = r"```(\w+)?\n([\s\S]+?)\n```"
-    md_str = re.sub(code_block_pattern, replacer, md_str, flags=re.MULTILINE)
-
-    html_str = markdown(md_str)
-    return html_str
-
-
-def normalize_markdown(md_text: str) -> str:
-    lines = md_text.split("\n")
-    normalized_lines = []
-    inside_list = False
-
-    for i, line in enumerate(lines):
-        if re.match(r"^(\d+\.|-|\*|\+)\s", line.strip()):
-            if not inside_list and i > 0 and lines[i - 1].strip() != "":
-                normalized_lines.append("")
-            inside_list = True
-            normalized_lines.append(line)
-        elif inside_list and line.strip() == "":
-            if i < len(lines) - 1 and not re.match(
-                r"^(\d+\.|-|\*|\+)\s", lines[i + 1].strip()
-            ):
-                normalized_lines.append(line)
-            continue
-        else:
-            inside_list = False
-            normalized_lines.append(line)
-
-    return "\n".join(normalized_lines)
-
-
-def convert_mdtext(md_text):
-    code_block_pattern = re.compile(r"```(.*?)(?:```|$)", re.DOTALL)
-    inline_code_pattern = re.compile(r"`(.*?)`", re.DOTALL)
-    code_blocks = code_block_pattern.findall(md_text)
-    non_code_parts = code_block_pattern.split(md_text)[::2]
-
-    result = []
-    for non_code, code in zip(non_code_parts, code_blocks + [""]):
-        if non_code.strip():
-            non_code = normalize_markdown(non_code)
-            if inline_code_pattern.search(non_code):
-                result.append(markdown(non_code, extensions=["tables"]))
-            else:
-                result.append(mdtex2html.convert(non_code, extensions=["tables"]))
-        if code.strip():
-            # _, code = detect_language(code)  # 暂时去除代码高亮功能，因为在大段代码的情况下会出现问题
-            # code = code.replace("\n\n", "\n") # 暂时去除代码中的空行，因为在大段代码的情况下会出现问题
-            code = f"\n```{code}\n\n```"
-            code = markdown_to_html_with_syntax_highlight(code)
-            result.append(code)
-    result = "".join(result)
-    result += ALREADY_CONVERTED_MARK
-    return result
-
-
-def convert_asis(userinput):
-    return (
-        f'<p style="white-space:pre-wrap;">{html.escape(userinput)}</p>'
-        + ALREADY_CONVERTED_MARK
-    )
-
-
-def detect_converted_mark(userinput):
-    if userinput.endswith(ALREADY_CONVERTED_MARK):
-        return True
-    else:
-        return False
-
-
-def detect_language(code):
-    if code.startswith("\n"):
-        first_line = ""
-    else:
-        first_line = code.strip().split("\n", 1)[0]
-    language = first_line.lower() if first_line else ""
-    code_without_language = code[len(first_line) :].lstrip() if first_line else code
-    return language, code_without_language
-
-
-def construct_text(role, text):
-    return {"role": role, "content": text}
-
-
-def construct_user(text):
-    return construct_text("user", text)
-
-
-def construct_system(text):
-    return construct_text("system", text)
-
-
-def construct_assistant(text):
-    return construct_text("assistant", text)
-
-
-def construct_token_message(tokens: List[int]):
-    token_sum = 0
-    for i in range(len(tokens)):
-        token_sum += sum(tokens[: i + 1])
-    return f"Token 计数: {sum(tokens)}，本次对话累计消耗了 {token_sum} tokens"
-
-
-def delete_first_conversation(history, previous_token_count):
-    if history:
-        del history[:2]
-        del previous_token_count[0]
-    return (
-        history,
-        previous_token_count,
-        construct_token_message(previous_token_count),
-    )
-
-
-def delete_last_conversation(chatbot, history, previous_token_count):
-    if len(chatbot) > 0 and standard_error_msg in chatbot[-1][1]:
-        logging.info("由于包含报错信息，只删除chatbot记录")
-        chatbot.pop()
-        return chatbot, history
-    if len(history) > 0:
-        logging.info("删除了一组对话历史")
-        history.pop()
-        history.pop()
-    if len(chatbot) > 0:
-        logging.info("删除了一组chatbot对话")
-        chatbot.pop()
-    if len(previous_token_count) > 0:
-        logging.info("删除了一组对话的token计数记录")
-        previous_token_count.pop()
-    return (
-        chatbot,
-        history,
-        previous_token_count,
-        construct_token_message(previous_token_count),
-    )
-
-
-def save_file(filename, system, history, chatbot, user_name):
-    logging.info(f"{user_name} 保存对话历史中……")
-    os.makedirs(HISTORY_DIR / user_name, exist_ok=True)
-    if filename.endswith(".json"):
-        json_s = {"system": system, "history": history, "chatbot": chatbot}
-        print(json_s)
-        with open(os.path.join(HISTORY_DIR / user_name, filename), "w") as f:
-            json.dump(json_s, f)
-    elif filename.endswith(".md"):
-        md_s = f"system: \n- {system} \n"
-        for data in history:
-            md_s += f"\n{data['role']}: \n- {data['content']} \n"
-        with open(os.path.join(HISTORY_DIR / user_name, filename), "w", encoding="utf8") as f:
-            f.write(md_s)
-    logging.info(f"{user_name} 保存对话历史完毕")
-    return os.path.join(HISTORY_DIR / user_name, filename)
-
-
-def save_chat_history(filename, system, history, chatbot, user_name):
-    if filename == "":
-        return
-    if not filename.endswith(".json"):
-        filename += ".json"
-    return save_file(filename, system, history, chatbot, user_name)
-
-
-def export_markdown(filename, system, history, chatbot, user_name):
-    if filename == "":
-        return
-    if not filename.endswith(".md"):
-        filename += ".md"
-    return save_file(filename, system, history, chatbot, user_name)
-
-
-def load_chat_history(filename, system, history, chatbot, user_name):
-    logging.info(f"{user_name} 加载对话历史中……")
-    if type(filename) != str:
-        filename = filename.name
-    try:
-        with open(os.path.join(HISTORY_DIR / user_name, filename), "r") as f:
-            json_s = json.load(f)
-        try:
-            if type(json_s["history"][0]) == str:
-                logging.info("历史记录格式为旧版，正在转换……")
-                new_history = []
-                for index, item in enumerate(json_s["history"]):
-                    if index % 2 == 0:
-                        new_history.append(construct_user(item))
-                    else:
-                        new_history.append(construct_assistant(item))
-                json_s["history"] = new_history
-                logging.info(new_history)
-        except:
-            # 没有对话历史
-            pass
-        logging.info(f"{user_name} 加载对话历史完毕")
-        return filename, json_s["system"], json_s["history"], json_s["chatbot"]
-    except FileNotFoundError:
-        logging.info(f"{user_name} 没有找到对话历史文件，不执行任何操作")
-        return filename, system, history, chatbot
-
-
-def sorted_by_pinyin(list):
-    return sorted(list, key=lambda char: lazy_pinyin(char)[0][0])
-
-
-def get_file_names(dir, plain=False, filetypes=[".json"]):
-    logging.info(f"获取文件名列表，目录为{dir}，文件类型为{filetypes}，是否为纯文本列表{plain}")
-    files = []
-    try:
-        for type in filetypes:
-            files += [f for f in os.listdir(dir) if f.endswith(type)]
-    except FileNotFoundError:
-        files = []
-    files = sorted_by_pinyin(files)
-    if files == []:
-        files = [""]
-    logging.debug(f"files are:{files}")
-    if plain:
-        return files
-    else:
-        return gr.Dropdown.update(choices=files)
-
-
-def get_history_names(plain=False, user_name=""):
-    logging.info(f"从用户 {user_name} 中获取历史记录文件名列表")
-    return get_file_names(HISTORY_DIR / user_name, plain)
-
-
-def load_template(filename, mode=0):
-    logging.info(f"加载模板文件{filename}，模式为{mode}（0为返回字典和下拉菜单，1为返回下拉菜单，2为返回字典）")
-    lines = []
-    logging.info("Loading template...")
-    if filename.endswith(".json"):
-        with open(os.path.join(TEMPLATES_DIR, filename), "r", encoding="utf8") as f:
-            lines = json.load(f)
-        lines = [[i["act"], i["prompt"]] for i in lines]
-    else:
-        with open(
-            os.path.join(TEMPLATES_DIR, filename), "r", encoding="utf8"
-        ) as csvfile:
-            reader = csv.reader(csvfile)
-            lines = list(reader)
-        lines = lines[1:]
-    if mode == 1:
-        return sorted_by_pinyin([row[0] for row in lines])
-    elif mode == 2:
-        return {row[0]: row[1] for row in lines}
-    else:
-        choices = sorted_by_pinyin([row[0] for row in lines])
-        return {row[0]: row[1] for row in lines}, gr.Dropdown.update(
-            choices=choices
-        )
-
-
-def get_template_names(plain=False):
-    logging.info("获取模板文件名列表")
-    return get_file_names(TEMPLATES_DIR, plain, filetypes=[".csv", "json"])
-
-
-def get_template_content(templates, selection, original_system_prompt):
-    logging.info(f"应用模板中，选择为{selection}，原始系统提示为{original_system_prompt}")
-    try:
-        return templates[selection]
-    except:
-        return original_system_prompt
-
-
-def reset_state():
-    logging.info("重置状态")
-    return [], [], [], construct_token_message([0])
-
-
-def reset_textbox():
-    logging.debug("重置文本框")
-    return gr.update(value="")
-
-
-def reset_default():
-    default_host = shared.state.reset_api_host()
-    retrieve_proxy("")
-    return gr.update(value=default_host), gr.update(value=""), "API-Host 和代理已重置"
-
-
-def change_api_host(host):
-    shared.state.set_api_host(host)
-    msg = f"API-Host更改为了{host}"
-    logging.info(msg)
-    return msg
-
-
-def change_proxy(proxy):
-    retrieve_proxy(proxy)
-    os.environ["HTTPS_PROXY"] = proxy
-    msg = f"代理更改为了{proxy}"
-    logging.info(msg)
-    return msg
-
-
-def hide_middle_chars(s):
-    if s is None:
-        return ""
-    if len(s) <= 8:
-        return s
-    else:
-        head = s[:4]
-        tail = s[-4:]
-        hidden = "*" * (len(s) - 8)
-        return head + hidden + tail
-
-
-def submit_key(key):
-    key = key.strip()
-    msg = f"API密钥更改为了{hide_middle_chars(key)}"
-    logging.info(msg)
-    return key, msg
-
-
-def replace_today(prompt):
-    today = datetime.datetime.today().strftime("%Y-%m-%d")
-    return prompt.replace("{current_date}", today)
-
-
-def get_geoip():
-    try:
-        with retrieve_proxy():
-            response = requests.get("https://ipapi.co/json/", timeout=5)
-        data = response.json()
-    except:
-        data = {"error": True, "reason": "连接ipapi失败"}
-    if "error" in data.keys():
-        logging.warning(f"无法获取IP地址信息。\n{data}")
-        if data["reason"] == "RateLimited":
-            return (
-                f"获取IP地理位置失败，因为达到了检测IP的速率限制。聊天功能可能仍然可用。"
-            )
-        else:
-            return f"获取IP地理位置失败。原因：{data['reason']}。你仍然可以使用聊天功能。"
-    else:
-        country = data["country_name"]
-        if country == "China":
-            text = "**您的IP区域：中国。请立即检查代理设置，在不受支持的地区使用API可能导致账号被封禁。**"
-        else:
-            text = f"您的IP区域：{country}。"
-        logging.info(text)
-        return text
-
-
-def find_n(lst, max_num):
-    n = len(lst)
-    total = sum(lst)
-
-    if total < max_num:
-        return n
-
-    for i in range(len(lst)):
-        if total - lst[i] < max_num:
-            return n - i - 1
-        total = total - lst[i]
-    return 1
-
-
-def start_outputing():
-    logging.debug("显示取消按钮，隐藏发送按钮")
-    return gr.Button.update(visible=True), gr.Button.update(visible=False)
-
-
-def end_outputing():
-    return (
-        gr.Button.update(visible=True),
-        gr.Button.update(visible=False),
-    )
-
-
-def cancel_outputing():
-    logging.info("中止输出……")
-    shared.state.interrupt()
-
-
-def transfer_input(inputs):
-    # 一次性返回，降低延迟
-    textbox = reset_textbox()
-    outputing = start_outputing()
-    return (
-        inputs,
-        gr.update(value=""),
-        gr.Button.update(visible=True),
-        gr.Button.update(visible=False),
-    )
-
-
-
-def run(command, desc=None, errdesc=None, custom_env=None, live=False):
-    if desc is not None:
-        print(desc)
-    if live:
-        result = subprocess.run(command, shell=True, env=os.environ if custom_env is None else custom_env)
-        if result.returncode != 0:
-            raise RuntimeError(f"""{errdesc or 'Error running command'}.
-Command: {command}
-Error code: {result.returncode}""")
-
-        return ""
-    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, env=os.environ if custom_env is None else custom_env)
-    if result.returncode != 0:
-        message = f"""{errdesc or 'Error running command'}.
-Command: {command}
-Error code: {result.returncode}
-stdout: {result.stdout.decode(encoding="utf8", errors="ignore") if len(result.stdout)>0 else '<empty>'}
-stderr: {result.stderr.decode(encoding="utf8", errors="ignore") if len(result.stderr)>0 else '<empty>'}
-"""
-        raise RuntimeError(message)
-    return result.stdout.decode(encoding="utf8", errors="ignore")
-
-def versions_html():
-    git = os.environ.get('GIT', "git")
-    python_version = ".".join([str(x) for x in sys.version_info[0:3]])
-    try:
-        commit_hash = run(f"{git} rev-parse HEAD").strip()
-    except Exception:
-        commit_hash = "<none>"
-    if commit_hash != "<none>":
-        short_commit = commit_hash[0:7]
-        commit_info = f"<a style=\"text-decoration:none\" href=\"https://github.com/GaiZhenbiao/ChuanhuChatGPT/commit/{short_commit}\">{short_commit}</a>"
-    else:
-        commit_info = "unknown \U0001F615"
-    return f"""
-Python: <span title="{sys.version}">{python_version}</span>
- • 
-Gradio: {gr.__version__}
- • 
-Commit: {commit_info}
-"""
-
-def add_source_numbers(lst, source_name = "Source", use_source = True):
-    if use_source:
-        return [f'[{idx+1}]\t "{item[0]}"\n{source_name}: {item[1]}' for idx, item in enumerate(lst)]
-    else:
-        return [f'[{idx+1}]\t "{item}"' for idx, item in enumerate(lst)]
-
-def add_details(lst):
-    nodes = []
-    for index, txt in enumerate(lst):
-        brief = txt[:25].replace("\n", "")
-        nodes.append(
-            f"<details><summary>{brief}...</summary><p>{txt}</p></details>"
-        )
-    return nodes
-
-
-def sheet_to_string(sheet):
-    result = ""
-    for index, row in sheet.iterrows():
-        row_string = ""
-        for column in sheet.columns:
-            row_string += f"{column}: {row[column]}, "
-        row_string = row_string.rstrip(", ")
-        row_string += "."
-        result += row_string + "\n"
-    return result
-
-def excel_to_string(file_path):
-    # 读取Excel文件中的所有工作表
-    excel_file = pd.read_excel(file_path, engine='openpyxl', sheet_name=None)
-
-    # 初始化结果字符串
-    result = ""
-
-    # 遍历每一个工作表
-    for sheet_name, sheet_data in excel_file.items():
-        # 将工作表名称添加到结果字符串
-        result += f"Sheet: {sheet_name}\n"
-
-        # 处理当前工作表并添加到结果字符串
-        result += sheet_to_string(sheet_data)
-
-        # 在不同工作表之间添加分隔符
-        result += "\n" + ("-" * 20) + "\n\n"
-
-    return result
diff --git a/spaces/suppsumstagza/text-to-image-stable-diffusion-v1-5/Java-A-Fondo-Pablo-Augusto-Sznajdleder-Pdf-Download.md b/spaces/suppsumstagza/text-to-image-stable-diffusion-v1-5/Java-A-Fondo-Pablo-Augusto-Sznajdleder-Pdf-Download.md
deleted file mode 100644
index 0775902b128bb22f68e1cd5837c3912389a2f822..0000000000000000000000000000000000000000
--- a/spaces/suppsumstagza/text-to-image-stable-diffusion-v1-5/Java-A-Fondo-Pablo-Augusto-Sznajdleder-Pdf-Download.md
+++ /dev/null
@@ -1,86 +0,0 @@
-## Java A Fondo Pablo Augusto Sznajdleder Pdf Download
-
-
-
- 
-
-  
-
- 
-
-**DOWNLOAD ★★★ [https://urlgoal.com/2txwax](https://urlgoal.com/2txwax)**
-
-
-
- 
-
- 
-
- 
-
- 
-
- 
-
-# How to Download Java a Fondo by Pablo Augusto Sznajdleder in PDF Format
-
- 
-
-If you are looking for a comprehensive and practical guide to learn Java programming, you may be interested in Java a Fondo by Pablo Augusto Sznajdleder. This book covers the fundamentals of the language, as well as advanced topics such as object-oriented programming, generics, collections, concurrency, networking, database access, GUI development, and web applications. In this article, we will show you how to download Java a Fondo by Pablo Augusto Sznajdleder in PDF format for free.
-
- 
-
-## What is Java a Fondo?
-
- 
-
-Java a Fondo is a book written by Pablo Augusto Sznajdleder, a software engineer and professor with more than 20 years of experience in teaching and developing Java applications. The book was first published in 2013 by Alfaomega Grupo Editor Argentino, and it has been updated to include the latest features of Java 8 and 9. The book has 456 pages and it is divided into 16 chapters that cover the following topics:
-
- 
-
-- The basics of Java: syntax, data types, operators, control structures, arrays, strings, input/output.
-
-- Object-oriented programming: classes, objects, inheritance, polymorphism, abstract classes, interfaces.
-
-- Generics: generic classes, methods, interfaces, wildcards, type inference.
-
-- Collections: lists, sets, maps, queues, iterators, comparators.
-
-- Concurrency: threads, synchronization, locks, executors, futures.
-
-- Networking: sockets, TCP/IP protocol, UDP protocol, URL connections.
-
-- Database access: JDBC API, drivers, connections, statements, result sets.
-
-- GUI development: Swing components, layouts, events, listeners.
-
-- Web applications: servlets, JSPs, MVC pattern.
-
-- And more: exceptions, assertions, annotations, reflection, lambda expressions.
-
-
-
-The book is written in Spanish and it is aimed at intermediate to advanced Java programmers who want to deepen their knowledge and skills in the language. The book is full of examples and exercises that illustrate the concepts and techniques explained in each chapter. The book also provides solutions to the exercises and source code for the examples on its website: [www.javaafondo.com.ar](http://www.javaafondo.com.ar).
-
- 
-
-## How to Download Java a Fondo by Pablo Augusto Sznajdleder in PDF Format?
-
- 
-
-If you want to download Java a Fondo by Pablo Augusto Sznajdleder in PDF format for free, you have two options:
-
-
-
-1. You can visit the official website of the book: [www.javaafondo.com.ar](http://www.javaafondo.com.ar). There you will find a link to download the PDF version of the book for free. You will need to register with your name and email address to access the download link. The PDF file has a size of 10.4 MB and it contains 456 pages.
-
-2. You can use a third-party website that offers free PDF downloads of books. One such website is [https://docs.google.com/viewer?a=v&pid=sites&srcid=ZGVmYXVsdGRvbWFpbnxjZWN5dGVtcG9vamF2YXxneDo4MjJkMzZlYTI2NWU1NGU](https://docs.google.com/viewer?a=v&pid=sites&srcid=ZGVmYXVsdGRvbWFpbnxjZWN5dGVtcG9vamF2YXxneDo4MjJkMzZlYTI2NWU1NGU). This website allows you to view and download the PDF file of Java a Fondo by Pablo Augusto Sznajdleder without registration or payment. The PDF file has a size of 10.4 MB and it contains 456 pages 1b8d091108
-
-
-
-
-
-
-
-
-
diff --git a/spaces/suppsumstagza/text-to-image-stable-diffusion-v1-5/scripts/Fxfactory Windows 7 Torrent.md b/spaces/suppsumstagza/text-to-image-stable-diffusion-v1-5/scripts/Fxfactory Windows 7 Torrent.md
deleted file mode 100644
index 9be89965cbaf4831d052df1a4efa77de0912bc2d..0000000000000000000000000000000000000000
--- a/spaces/suppsumstagza/text-to-image-stable-diffusion-v1-5/scripts/Fxfactory Windows 7 Torrent.md	
+++ /dev/null
@@ -1,8 +0,0 @@
-<h2>Fxfactory Windows 7 Torrent</h2><br /><p><b><b>Download File</b> &#9913; <a href="https://cinurl.com/2uEXrl">https://cinurl.com/2uEXrl</a></b></p><br /><br />
-
-October 27, 2564 B.C. e. — FxFactory Crack Pro 7 is a free plugin management system where users install and try a good collection of plugins.## #November 21, 2564 B.C. - This application allows you to access visual effects, as well as manage installed effects. FxFactory Pro 7.2.6 Crack + Serial Free. # #February 11, 2564 B.C. — FxFactory Crack Pro 7 is a collection of the best plugins
-for web programmers. # # February 20, 2564 B.C. - FxFactory Crack Pro 7 is a video editing software that can edit videos, add video effects and make video effects. # #30 March 2564 BC - FxFactory Crack Pro 7 is a movie editor for video and audio files. # #April 14, 2564 B.C. — FxFactory Crack Pro 7 is a program with many
-video effects which 8a78ff9644<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/suppsumstagza/text-to-image-stable-diffusion-v1-5/scripts/Mysms Premium Cracked Apk For Androidinstmank Zip.md b/spaces/suppsumstagza/text-to-image-stable-diffusion-v1-5/scripts/Mysms Premium Cracked Apk For Androidinstmank Zip.md
deleted file mode 100644
index e5445386bd7e44960520061db96fcfb127cce0f3..0000000000000000000000000000000000000000
--- a/spaces/suppsumstagza/text-to-image-stable-diffusion-v1-5/scripts/Mysms Premium Cracked Apk For Androidinstmank Zip.md	
+++ /dev/null
@@ -1,26 +0,0 @@
-<h2>Mysms Premium Cracked Apk For Androidinstmank zip</h2><br /><p><b><b>Download</b> &#9999; <a href="https://cinurl.com/2uEYvB">https://cinurl.com/2uEYvB</a></b></p><br /><br />
-<br />
-Latest Version The Best Version.cracked Mod Version, Fully Game And Data, No Root Need!.
-
-Description
-
-It is the most engaging and thrilling football experience ever. From day one, soccer may have seemed like just a game played by children, but now you can join the battle for soccer glory with the sport’s most popular teams! Take the field with your favorite teams including Barcelona, Chelsea, Manchester United, AC Milan, and more! Now you can experience your favorite football teams in a realistic, engaging 3D environment. Take on the challenges, play in the games, and collect exclusive team gear to lead your team to victory! The more you play, the more authentic the game experience will become. Your team can make historic achievements, be crowned champion, and even win the World Cup!
-
-Features
-
-• Authentic 3D environment. Play in the same stadium as your favorite teams!• Play games with your teammates and have fun.• Beat your friends with challenging online modes.• Uncover the best squad of players.• Compete against the world’s best teams.• Complete achievements.• Play on any mobile device.• Use your favorite team as your avatar.
-
-Privacy Policy: The official status of any listing on this website cannot be reviewed until the developer has provided us with an E-mail address. Some of the developers have not yet provided us with E-mail addresses. We will continue to post listings until they have.
-
-In the interim, we can provide you with the following information about the developer:
-
-Scoop.It is the official mobile app from Harpers Ferry, WV. Created by award-winning director Robert K. Lee, Scoop! brings you the latest news, sports, entertainment, food and fashion!
-
-Scoop is your window to all the things that matter in Harpers Ferry, WV.
-
-Whether you want to read the latest news from Harpers Ferry's official newspaper, watch your favorite local or national news, listen to the latest music, check out the area's best restaurants, look at your Facebook friends, find out who's playing at Harpers Ferry's major venues or listen to the hottest music, Scoop is your window to everything that matters in Harpers Ferry.
-
-Scoop.It is the official mobile app from Harpers Ferry, WV. Created by award-winning director Robert K. Lee, Scoop! brings you the latest news, sports, 4fefd39f24<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/svjack/ControlNet-Pose-Chinese/annotator/uniformer/__init__.py b/spaces/svjack/ControlNet-Pose-Chinese/annotator/uniformer/__init__.py
deleted file mode 100644
index 6be429542e4908c2b7648e7ee7c9c5f8253e7c94..0000000000000000000000000000000000000000
--- a/spaces/svjack/ControlNet-Pose-Chinese/annotator/uniformer/__init__.py
+++ /dev/null
@@ -1,23 +0,0 @@
-import os
-
-from annotator.uniformer.mmseg.apis import init_segmentor, inference_segmentor, show_result_pyplot
-from annotator.uniformer.mmseg.core.evaluation import get_palette
-from annotator.util import annotator_ckpts_path
-
-
-checkpoint_file = "https://huggingface.co/lllyasviel/ControlNet/resolve/main/annotator/ckpts/upernet_global_small.pth"
-
-
-class UniformerDetector:
-    def __init__(self):
-        modelpath = os.path.join(annotator_ckpts_path, "upernet_global_small.pth")
-        if not os.path.exists(modelpath):
-            from basicsr.utils.download_util import load_file_from_url
-            load_file_from_url(checkpoint_file, model_dir=annotator_ckpts_path)
-        config_file = os.path.join(os.path.dirname(annotator_ckpts_path), "uniformer", "exp", "upernet_global_small", "config.py")
-        self.model = init_segmentor(config_file, modelpath).cuda()
-
-    def __call__(self, img):
-        result = inference_segmentor(self.model, img)
-        res_img = show_result_pyplot(self.model, img, result, get_palette('ade'), opacity=1)
-        return res_img
diff --git a/spaces/syy404/whisper-webui/src/vad.py b/spaces/syy404/whisper-webui/src/vad.py
deleted file mode 100644
index 318e467ac230830fc4a7dd7c5295d23d1d04a31f..0000000000000000000000000000000000000000
--- a/spaces/syy404/whisper-webui/src/vad.py
+++ /dev/null
@@ -1,537 +0,0 @@
-from abc import ABC, abstractmethod
-from collections import Counter, deque
-import time
-
-from typing import Any, Deque, Iterator, List, Dict
-
-from pprint import pprint
-from src.modelCache import GLOBAL_MODEL_CACHE, ModelCache
-
-from src.segments import merge_timestamps
-from src.whisperContainer import WhisperCallback
-
-# Workaround for https://github.com/tensorflow/tensorflow/issues/48797
-try:
-    import tensorflow as tf
-except ModuleNotFoundError:
-    # Error handling
-    pass
-
-import torch
-
-import ffmpeg
-import numpy as np
-
-from src.utils import format_timestamp
-from enum import Enum
-
-class NonSpeechStrategy(Enum):
-    """
-    Ignore non-speech frames segments.
-    """
-    SKIP = 1
-    """
-    Just treat non-speech segments as speech.
-    """
-    CREATE_SEGMENT = 2
-    """
-    Expand speech segments into subsequent non-speech segments.
-    """
-    EXPAND_SEGMENT = 3
-
-# Defaults for Silero
-SPEECH_TRESHOLD = 0.3
-
-# Minimum size of segments to process
-MIN_SEGMENT_DURATION = 1
-
-# The maximum time for texts from old segments to be used in the next segment 
-MAX_PROMPT_WINDOW = 0 # seconds (0 = disabled)
-PROMPT_NO_SPEECH_PROB = 0.1 # Do not pass the text from segments with a no speech probability higher than this
-
-VAD_MAX_PROCESSING_CHUNK = 60 * 60 # 60 minutes of audio
-
-class TranscriptionConfig(ABC):
-    def __init__(self, non_speech_strategy: NonSpeechStrategy = NonSpeechStrategy.SKIP, 
-                       segment_padding_left: float = None, segment_padding_right = None, max_silent_period: float = None, 
-                       max_merge_size: float = None, max_prompt_window: float = None, initial_segment_index = -1):
-        self.non_speech_strategy = non_speech_strategy
-        self.segment_padding_left = segment_padding_left
-        self.segment_padding_right = segment_padding_right
-        self.max_silent_period = max_silent_period
-        self.max_merge_size = max_merge_size
-        self.max_prompt_window = max_prompt_window
-        self.initial_segment_index = initial_segment_index
-
-class PeriodicTranscriptionConfig(TranscriptionConfig):
-    def __init__(self, periodic_duration: float, non_speech_strategy: NonSpeechStrategy = NonSpeechStrategy.SKIP, 
-                       segment_padding_left: float = None, segment_padding_right = None, max_silent_period: float = None, 
-                       max_merge_size: float = None, max_prompt_window: float = None, initial_segment_index = -1):
-        super().__init__(non_speech_strategy, segment_padding_left, segment_padding_right, max_silent_period, max_merge_size, max_prompt_window, initial_segment_index)
-        self.periodic_duration = periodic_duration
-
-class AbstractTranscription(ABC):
-    def __init__(self, sampling_rate: int = 16000):
-        self.sampling_rate = sampling_rate
-
-    def get_audio_segment(self, str, start_time: str = None, duration: str = None):
-        return load_audio(str, self.sampling_rate, start_time, duration)
-
-    def is_transcribe_timestamps_fast(self):
-        """
-        Determine if get_transcribe_timestamps is fast enough to not need parallelization.
-        """
-        return False
-
-    @abstractmethod
-    def get_transcribe_timestamps(self, audio: str, config: TranscriptionConfig, start_time: float, end_time: float):
-        """
-        Get the start and end timestamps of the sections that should be transcribed by this VAD method.
-
-        Parameters
-        ----------
-        audio: str
-            The audio file.
-        config: TranscriptionConfig
-            The transcription configuration.
-
-        Returns
-        -------
-        A list of start and end timestamps, in fractional seconds.
-        """
-        return 
-
-    def get_merged_timestamps(self, timestamps: List[Dict[str, Any]], config: TranscriptionConfig, total_duration: float):
-        """
-        Get the start and end timestamps of the sections that should be transcribed by this VAD method,
-        after merging the given segments using the specified configuration.
-
-        Parameters
-        ----------
-        audio: str
-            The audio file. 
-        config: TranscriptionConfig
-            The transcription configuration.
-
-        Returns
-        -------
-        A list of start and end timestamps, in fractional seconds.
-        """
-        merged = merge_timestamps(timestamps, config.max_silent_period, config.max_merge_size, 
-                                  config.segment_padding_left, config.segment_padding_right)
-
-        if config.non_speech_strategy != NonSpeechStrategy.SKIP:
-            # Expand segments to include the gaps between them
-            if (config.non_speech_strategy == NonSpeechStrategy.CREATE_SEGMENT):
-                # When we have a prompt window, we create speech segments betwen each segment if we exceed the merge size
-                merged = self.fill_gaps(merged, total_duration=total_duration, max_expand_size=config.max_merge_size)
-            elif config.non_speech_strategy == NonSpeechStrategy.EXPAND_SEGMENT: 
-                # With no prompt window, it is better to just expand the segments (this effectively passes the prompt to the next segment)
-                merged = self.expand_gaps(merged, total_duration=total_duration)
-            else:
-                raise Exception("Unknown non-speech strategy: " + str(config.non_speech_strategy))
-
-            print("Transcribing non-speech:")
-            pprint(merged)
-        return merged
-
-    def transcribe(self, audio: str, whisperCallable: WhisperCallback, config: TranscriptionConfig):
-        """
-        Transcribe the given audo file.
-
-        Parameters
-        ----------
-        audio: str
-            The audio file.
-        whisperCallable: WhisperCallback
-            A callback object to call to transcribe each segment.
-
-        Returns
-        -------
-        A list of start and end timestamps, in fractional seconds.
-        """
-
-        max_audio_duration = get_audio_duration(audio)
-        timestamp_segments = self.get_transcribe_timestamps(audio, config, 0, max_audio_duration)
-
-        # Get speech timestamps from full audio file
-        merged = self.get_merged_timestamps(timestamp_segments, config, max_audio_duration)
-
-        # A deque of transcribed segments that is passed to the next segment as a prompt
-        prompt_window = deque()
-
-        print("Processing timestamps:")
-        pprint(merged)
-
-        result = {
-            'text': "",
-            'segments': [],
-            'language': ""
-        }
-        languageCounter = Counter()
-        detected_language = None
-
-        segment_index = config.initial_segment_index
-
-        # For each time segment, run whisper
-        for segment in merged:
-            segment_index += 1
-            segment_start = segment['start']
-            segment_end = segment['end']
-            segment_expand_amount = segment.get('expand_amount', 0)
-            segment_gap = segment.get('gap', False)
-
-            segment_duration = segment_end - segment_start
-
-            if segment_duration < MIN_SEGMENT_DURATION:
-                continue;
-
-            # Audio to run on Whisper
-            segment_audio = self.get_audio_segment(audio, start_time = str(segment_start), duration = str(segment_duration))
-            # Previous segments to use as a prompt
-            segment_prompt = ' '.join([segment['text'] for segment in prompt_window]) if len(prompt_window) > 0 else None
-    
-            # Detected language
-            detected_language = languageCounter.most_common(1)[0][0] if len(languageCounter) > 0 else None
-
-            print("Running whisper from ", format_timestamp(segment_start), " to ", format_timestamp(segment_end), ", duration: ", 
-                  segment_duration, "expanded: ", segment_expand_amount, "prompt: ", segment_prompt, "language: ", detected_language)
-            segment_result = whisperCallable.invoke(segment_audio, segment_index, segment_prompt, detected_language)
-
-            adjusted_segments = self.adjust_timestamp(segment_result["segments"], adjust_seconds=segment_start, max_source_time=segment_duration)
-
-            # Propagate expand amount to the segments
-            if (segment_expand_amount > 0):
-                segment_without_expansion = segment_duration - segment_expand_amount
-
-                for adjusted_segment in adjusted_segments:
-                    adjusted_segment_end = adjusted_segment['end']
-
-                    # Add expand amount if the segment got expanded
-                    if (adjusted_segment_end > segment_without_expansion):
-                        adjusted_segment["expand_amount"] = adjusted_segment_end - segment_without_expansion
-
-            # Append to output
-            result['text'] += segment_result['text']
-            result['segments'].extend(adjusted_segments)
-
-            # Increment detected language
-            if not segment_gap:
-                languageCounter[segment_result['language']] += 1
-
-            # Update prompt window
-            self.__update_prompt_window(prompt_window, adjusted_segments, segment_end, segment_gap, config)
-            
-        if detected_language is not None:
-            result['language'] = detected_language
-
-        return result
-            
-    def __update_prompt_window(self, prompt_window: Deque, adjusted_segments: List, segment_end: float, segment_gap: bool, config: TranscriptionConfig):
-        if (config.max_prompt_window is not None and config.max_prompt_window > 0):
-            # Add segments to the current prompt window (unless it is a speech gap)
-            if not segment_gap:
-                for segment in adjusted_segments:
-                    if segment.get('no_speech_prob', 0) <= PROMPT_NO_SPEECH_PROB:
-                        prompt_window.append(segment)
-
-            while (len(prompt_window) > 0):
-                first_end_time = prompt_window[0].get('end', 0)
-                # Time expanded in the segments should be discounted from the prompt window
-                first_expand_time = prompt_window[0].get('expand_amount', 0)
-
-                if (first_end_time - first_expand_time < segment_end - config.max_prompt_window):
-                    prompt_window.popleft()
-                else:
-                    break
-
-    def include_gaps(self, segments: Iterator[dict], min_gap_length: float, total_duration: float):
-        result = []
-        last_end_time = 0
-
-        for segment in segments:
-            segment_start = float(segment['start'])
-            segment_end = float(segment['end'])
-
-            if (last_end_time != segment_start):
-                delta = segment_start - last_end_time
-
-                if (min_gap_length is None or delta >= min_gap_length):
-                    result.append( { 'start': last_end_time, 'end': segment_start, 'gap': True } )
-            
-            last_end_time = segment_end
-            result.append(segment)
-
-        # Also include total duration if specified
-        if (total_duration is not None and last_end_time < total_duration):
-            delta = total_duration - segment_start
-
-            if (min_gap_length is None or delta >= min_gap_length):
-                result.append( { 'start': last_end_time, 'end': total_duration, 'gap': True } )
-
-        return result
-
-    # Expand the end time of each segment to the start of the next segment
-    def expand_gaps(self, segments: List[Dict[str, Any]], total_duration: float):
-        result = []
-
-        if len(segments) == 0:
-            return result
-
-        # Add gap at the beginning if needed
-        if (segments[0]['start'] > 0):
-            result.append({ 'start': 0, 'end': segments[0]['start'], 'gap': True } )
-
-        for i in range(len(segments) - 1):
-            current_segment = segments[i]
-            next_segment = segments[i + 1]
-
-            delta = next_segment['start'] - current_segment['end']
-
-            # Expand if the gap actually exists
-            if (delta >= 0):
-                current_segment = current_segment.copy()
-                current_segment['expand_amount'] = delta
-                current_segment['end'] = next_segment['start']
-            
-            result.append(current_segment)
-
-        # Add last segment
-        last_segment = segments[-1]
-        result.append(last_segment)
-
-        # Also include total duration if specified
-        if (total_duration is not None):
-            last_segment = result[-1]
-
-            if (last_segment['end'] < total_duration):
-                last_segment = last_segment.copy()
-                last_segment['end'] = total_duration
-                result[-1] = last_segment
-
-        return result
-
-    def fill_gaps(self, segments: List[Dict[str, Any]], total_duration: float, max_expand_size: float = None):
-        result = []
-
-        if len(segments) == 0:
-            return result
-
-        # Add gap at the beginning if needed
-        if (segments[0]['start'] > 0):
-            result.append({ 'start': 0, 'end': segments[0]['start'], 'gap': True } )
-
-        for i in range(len(segments) - 1):
-            expanded = False
-            current_segment = segments[i]
-            next_segment = segments[i + 1]
-
-            delta = next_segment['start'] - current_segment['end']
-
-            if (max_expand_size is not None and delta <= max_expand_size):
-                # Just expand the current segment
-                current_segment = current_segment.copy()
-                current_segment['expand_amount'] = delta
-                current_segment['end'] = next_segment['start']
-                expanded = True
-
-            result.append(current_segment)
-
-            # Add a gap to the next segment if needed
-            if (delta >= 0 and not expanded):
-                result.append({ 'start': current_segment['end'], 'end': next_segment['start'], 'gap': True } )
-            
-        # Add last segment
-        last_segment = segments[-1]
-        result.append(last_segment)
-
-        # Also include total duration if specified
-        if (total_duration is not None):
-            last_segment = result[-1]
-
-            delta = total_duration - last_segment['end']
-
-            if (delta > 0):
-                if (max_expand_size is not None and delta <= max_expand_size):
-                    # Expand the last segment
-                    last_segment = last_segment.copy()
-                    last_segment['expand_amount'] = delta
-                    last_segment['end'] = total_duration
-                    result[-1] = last_segment
-                else:
-                    result.append({ 'start': last_segment['end'], 'end': total_duration, 'gap': True } )
-
-        return result
-
-    def adjust_timestamp(self, segments: Iterator[dict], adjust_seconds: float, max_source_time: float = None):
-        result = []
-
-        for segment in segments:
-            segment_start = float(segment['start'])
-            segment_end = float(segment['end'])
-
-            # Filter segments?
-            if (max_source_time is not None):
-                if (segment_start > max_source_time):
-                    continue
-                segment_end = min(max_source_time, segment_end)
-
-                new_segment = segment.copy()
-
-            # Add to start and end
-            new_segment['start'] = segment_start + adjust_seconds
-            new_segment['end'] = segment_end + adjust_seconds
-            result.append(new_segment)
-        return result
-
-    def multiply_timestamps(self, timestamps: List[Dict[str, Any]], factor: float):
-        result = []
-
-        for entry in timestamps:
-            start = entry['start']
-            end = entry['end']
-
-            result.append({
-                'start': start * factor,
-                'end': end * factor
-            })
-        return result
-
-
-class VadSileroTranscription(AbstractTranscription):
-    def __init__(self, sampling_rate: int = 16000, cache: ModelCache = None):
-        super().__init__(sampling_rate=sampling_rate)
-        self.model = None
-        self.cache = cache
-        self._initialize_model()
-
-    def _initialize_model(self):
-        if (self.cache is not None):
-            model_key = "VadSileroTranscription"
-            self.model, self.get_speech_timestamps = self.cache.get(model_key, self._create_model)
-            print("Loaded Silerio model from cache.")
-        else:
-            self.model, self.get_speech_timestamps = self._create_model()
-            print("Created Silerio model")
-
-    def _create_model(self):
-        model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad')
-        
-        # Silero does not benefit from multi-threading
-        torch.set_num_threads(1) # JIT
-        (get_speech_timestamps, _, _, _, _) = utils
-
-        return model, get_speech_timestamps
-
-    def get_transcribe_timestamps(self, audio: str, config: TranscriptionConfig, start_time: float, end_time: float):
-        result = []
-
-        print("Getting timestamps from audio file: {}, start: {}, duration: {}".format(audio, start_time, end_time))
-        perf_start_time = time.perf_counter()
-
-        # Divide procesisng of audio into chunks
-        chunk_start = start_time
-
-        while (chunk_start < end_time):
-            chunk_duration = min(end_time - chunk_start, VAD_MAX_PROCESSING_CHUNK)
-
-            print("Processing VAD in chunk from {} to {}".format(format_timestamp(chunk_start), format_timestamp(chunk_start + chunk_duration)))
-            wav = self.get_audio_segment(audio, str(chunk_start), str(chunk_duration))
-
-            sample_timestamps = self.get_speech_timestamps(wav, self.model, sampling_rate=self.sampling_rate, threshold=SPEECH_TRESHOLD)
-            seconds_timestamps = self.multiply_timestamps(sample_timestamps, factor=1 / self.sampling_rate) 
-            adjusted = self.adjust_timestamp(seconds_timestamps, adjust_seconds=chunk_start, max_source_time=chunk_start + chunk_duration)
-
-            #pprint(adjusted)
-
-            result.extend(adjusted)
-            chunk_start += chunk_duration
-
-        perf_end_time = time.perf_counter()
-        print("VAD processing took {} seconds".format(perf_end_time - perf_start_time))
-
-        return result
-
-    def __getstate__(self):
-        # We only need the sampling rate
-        return { 'sampling_rate': self.sampling_rate }
-
-    def __setstate__(self, state):
-        self.sampling_rate = state['sampling_rate']
-        self.model = None
-        # Use the global cache
-        self.cache = GLOBAL_MODEL_CACHE
-        self._initialize_model()
-
-# A very simple VAD that just marks every N seconds as speech
-class VadPeriodicTranscription(AbstractTranscription):
-    def __init__(self, sampling_rate: int = 16000):
-        super().__init__(sampling_rate=sampling_rate)
-
-    def is_transcribe_timestamps_fast(self):
-        # This is a very fast VAD - no need to parallelize it
-        return True
-
-    def get_transcribe_timestamps(self, audio: str, config: PeriodicTranscriptionConfig, start_time: float, end_time: float):
-        result = []
-
-        # Generate a timestamp every N seconds
-        start_timestamp = start_time
-
-        while (start_timestamp < end_time):
-            end_timestamp = min(start_timestamp + config.periodic_duration, end_time)
-            segment_duration = end_timestamp - start_timestamp
-
-            # Minimum duration is 1 second
-            if (segment_duration >= 1):
-                result.append( {  'start': start_timestamp, 'end': end_timestamp } )
-
-            start_timestamp = end_timestamp
-
-        return result
-
-def get_audio_duration(file: str):
-    return float(ffmpeg.probe(file)["format"]["duration"])
-
-def load_audio(file: str, sample_rate: int = 16000, 
-               start_time: str = None, duration: str = None):
-    """
-    Open an audio file and read as mono waveform, resampling as necessary
-
-    Parameters
-    ----------
-    file: str
-        The audio file to open
-
-    sr: int
-        The sample rate to resample the audio if necessary
-
-    start_time: str
-        The start time, using the standard FFMPEG time duration syntax, or None to disable.
-    
-    duration: str
-        The duration, using the standard FFMPEG time duration syntax, or None to disable.
-
-    Returns
-    -------
-    A NumPy array containing the audio waveform, in float32 dtype.
-    """
-    try:
-        inputArgs = {'threads': 0}
-
-        if (start_time is not None):
-            inputArgs['ss'] = start_time
-        if (duration is not None):
-            inputArgs['t'] = duration
-
-        # This launches a subprocess to decode audio while down-mixing and resampling as necessary.
-        # Requires the ffmpeg CLI and `ffmpeg-python` package to be installed.
-        out, _ = (
-            ffmpeg.input(file, **inputArgs)
-            .output("-", format="s16le", acodec="pcm_s16le", ac=1, ar=sample_rate)
-            .run(cmd="ffmpeg", capture_stdout=True, capture_stderr=True)
-        )
-    except ffmpeg.Error as e:
-        raise RuntimeError(f"Failed to load audio: {e.stderr.decode()}")
-
-    return np.frombuffer(out, np.int16).flatten().astype(np.float32) / 32768.0
\ No newline at end of file
diff --git a/spaces/tabeina/bingo1/src/components/settings.tsx b/spaces/tabeina/bingo1/src/components/settings.tsx
deleted file mode 100644
index 80b8a2d3b252b875f5b6f7dfc2f6e3ad9cdfb22a..0000000000000000000000000000000000000000
--- a/spaces/tabeina/bingo1/src/components/settings.tsx
+++ /dev/null
@@ -1,157 +0,0 @@
-import { useEffect, useState } from 'react'
-import { useAtom } from 'jotai'
-import { Switch } from '@headlessui/react'
-import { toast } from 'react-hot-toast'
-import { hashAtom, voiceAtom } from '@/state'
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle
-} from '@/components/ui/dialog'
-import { Button } from './ui/button'
-import { Input } from './ui/input'
-import { ChunkKeys, parseCookies, extraCurlFromCookie, encodeHeadersToCookie, getCookie, setCookie } from '@/lib/utils'
-import { ExternalLink } from './external-link'
-import { useCopyToClipboard } from '@/lib/hooks/use-copy-to-clipboard'
-
-
-export function Settings() {
-  const { isCopied, copyToClipboard } = useCopyToClipboard({ timeout: 2000 })
-  const [loc, setLoc] = useAtom(hashAtom)
-  const [curlValue, setCurlValue] = useState(extraCurlFromCookie(parseCookies(document.cookie, ChunkKeys)))
-  const [imageOnly, setImageOnly] = useState(getCookie('IMAGE_ONLY') !== '0')
-  const [enableTTS, setEnableTTS] = useAtom(voiceAtom)
-
-  useEffect(() => {
-    if (isCopied) {
-      toast.success('复制成功')
-    }
-  }, [isCopied])
-
-  if (loc === 'settings') {
-    return (
-      <Dialog open onOpenChange={() => setLoc('')} modal>
-        <DialogContent>
-          <DialogHeader>
-            <DialogTitle>设置你的用户信息</DialogTitle>
-            <DialogDescription>
-              请使用 Edge 浏览器
-              <ExternalLink
-                href="https://www.bing.com/turing/captcha/challenge"
-              >
-                打开并登录 Bing
-              </ExternalLink>
-              ，然后再打开
-              <ExternalLink href="https://www.bing.com/turing/captcha/challenge">Challenge 接口</ExternalLink>
-              右键 》检查。打开开发者工具，在网络里面找到 Create 接口 》右键复制》复制为 cURL(bash)，粘贴到此处，然后保存。
-              <div className="h-2" />
-              图文示例：
-              <ExternalLink href="https://github.com/weaigc/bingo#如何获取%20BING_HEADER">如何获取 BING_HEADER</ExternalLink>
-            </DialogDescription>
-          </DialogHeader>
-          <div className="flex gap-4">
-
-          </div>
-          <Input
-            value={curlValue}
-            placeholder="在此填写用户信息，格式: curl 'https://www.bing.com/turing/captcha/challenge' ..."
-            onChange={e => setCurlValue(e.target.value)}
-          />
-          <div className="flex gap-2">
-            身份信息仅用于画图（推荐）
-            <Switch
-              checked={imageOnly}
-              className={`${imageOnly ? 'bg-blue-600' : 'bg-gray-200'} relative inline-flex h-6 w-11 items-center rounded-full`}
-              onChange={(checked: boolean) => setImageOnly(checked)}
-            >
-              <span
-                className={`${imageOnly ? 'translate-x-6' : 'translate-x-1'} inline-block h-4 w-4 transform rounded-full bg-white transition`}
-              />
-            </Switch>
-          </div>
-
-          <Button variant="ghost" className="bg-[#F5F5F5] hover:bg-[#F2F2F2]" onClick={() => copyToClipboard(btoa(curlValue))}>
-            转成 BING_HEADER 并复制
-          </Button>
-
-          <DialogFooter className="items-center">
-            <Button
-              variant="secondary"
-              className="bg-[#c7f3ff] hover:bg-[#fdc7ff]"
-              onClick={() => {
-                let headerValue = curlValue
-                if (headerValue) {
-                  try {
-                    headerValue = atob(headerValue)
-                  } catch (e) { }
-                  if (!/^\s*curl ['"]https:\/\/(www|cn)\.bing\.com\/turing\/captcha\/challenge['"]/.test(headerValue)) {
-                    toast.error('格式不正确')
-                    return
-                  }
-                  const maxAge = 86400 * 30
-                  encodeHeadersToCookie(headerValue).forEach(cookie => document.cookie = `${cookie}; Max-Age=${maxAge}; Path=/; SameSite=None; Secure`)
-                } else {
-                  [...ChunkKeys, 'BING_COOKIE', 'BING_UA', 'BING_IP'].forEach(key => setCookie(key, ''))
-                }
-                setCookie('IMAGE_ONLY', RegExp.$1 === 'cn' || imageOnly ? '1' : '0')
-
-                toast.success('保存成功')
-                setLoc('')
-                setTimeout(() => {
-                  location.href = './'
-                }, 2000)
-              }}
-            >
-              保存
-            </Button>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-    )
-  } else if (loc === 'voice') {
-    return (
-      <Dialog open onOpenChange={() => setLoc('')} modal>
-        <DialogContent>
-          <DialogHeader>
-            <DialogTitle>语音设置</DialogTitle>
-            <DialogDescription>
-              目前仅支持 PC 端 Edge 及 Chrome 浏览器
-            </DialogDescription>
-          </DialogHeader>
-
-          <div className="flex gap-2">
-            启用语音回答
-            <Switch
-              checked={enableTTS}
-              className={`${enableTTS ? 'bg-blue-600' : 'bg-gray-200'} relative inline-flex h-6 w-11 items-center rounded-full`}
-              onChange={(checked: boolean) => setEnableTTS(checked)}
-            >
-              <span
-                className={`${enableTTS ? 'translate-x-6' : 'translate-x-1'} inline-block h-4 w-4 transform rounded-full bg-white transition`}
-              />
-            </Switch>
-          </div>
-
-          <DialogFooter className="items-center">
-            <Button
-              variant="secondary"
-              onClick={() => {
-                toast.success('保存成功')
-                setLoc('')
-                setTimeout(() => {
-                  location.href = './'
-                }, 2000)
-              }}
-            >
-              保存
-            </Button>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-    )
-  }
-  return null
-}
diff --git a/spaces/taesiri/DeticChatGPT/detic/data/datasets/cc.py b/spaces/taesiri/DeticChatGPT/detic/data/datasets/cc.py
deleted file mode 100644
index 7c3e50726f781dba4c72d4e18f4922e503218af8..0000000000000000000000000000000000000000
--- a/spaces/taesiri/DeticChatGPT/detic/data/datasets/cc.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import logging
-import os
-
-from detectron2.data.datasets.builtin_meta import _get_builtin_metadata
-from detectron2.data.datasets.lvis import get_lvis_instances_meta
-from .lvis_v1 import custom_register_lvis_instances
-
-_CUSTOM_SPLITS = {
-    "cc3m_v1_val": ("cc3m/validation/", "cc3m/val_image_info.json"),
-    "cc3m_v1_train": ("cc3m/training/", "cc3m/train_image_info.json"),
-    "cc3m_v1_train_tags": ("cc3m/training/", "cc3m/train_image_info_tags.json"),
-
-}
-
-for key, (image_root, json_file) in _CUSTOM_SPLITS.items():
-    custom_register_lvis_instances(
-        key,
-        get_lvis_instances_meta('lvis_v1'),
-        os.path.join("datasets", json_file) if "://" not in json_file else json_file,
-        os.path.join("datasets", image_root),
-    )
-
diff --git a/spaces/taesiri/DeticChatGPT/detic/data/tar_dataset.py b/spaces/taesiri/DeticChatGPT/detic/data/tar_dataset.py
deleted file mode 100644
index 0605ba3a96ab80a1212fdb1a3860337d7e7b20cc..0000000000000000000000000000000000000000
--- a/spaces/taesiri/DeticChatGPT/detic/data/tar_dataset.py
+++ /dev/null
@@ -1,138 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) Facebook, Inc. and its affiliates.
-import os
-import gzip
-import numpy as np
-import io
-from PIL import Image
-from torch.utils.data import Dataset
-
-try:
-    from PIL import UnidentifiedImageError
-
-    unidentified_error_available = True
-except ImportError:
-    # UnidentifiedImageError isn't available in older versions of PIL
-    unidentified_error_available = False
-
-class DiskTarDataset(Dataset):
-    def __init__(self, 
-        tarfile_path='dataset/imagenet/ImageNet-21k/metadata/tar_files.npy',
-        tar_index_dir='dataset/imagenet/ImageNet-21k/metadata/tarindex_npy',
-        preload=False, 
-        num_synsets="all"):
-        """
-        - preload (bool): Recommend to set preload to False when using
-        - num_synsets (integer or string "all"): set to small number for debugging
-            will load subset of dataset
-        """
-        tar_files = np.load(tarfile_path)
-
-        chunk_datasets = []
-        dataset_lens = []
-        if isinstance(num_synsets, int):
-            assert num_synsets < len(tar_files)
-            tar_files = tar_files[:num_synsets]
-        for tar_file in tar_files:
-            dataset = _TarDataset(tar_file, tar_index_dir, preload=preload)
-            chunk_datasets.append(dataset)
-            dataset_lens.append(len(dataset))
-
-        self.chunk_datasets = chunk_datasets
-        self.dataset_lens = np.array(dataset_lens).astype(np.int32)
-        self.dataset_cumsums = np.cumsum(self.dataset_lens)
-        self.num_samples = sum(self.dataset_lens)
-        labels = np.zeros(self.dataset_lens.sum(), dtype=np.int64)
-        sI = 0
-        for k in range(len(self.dataset_lens)):
-            assert (sI+self.dataset_lens[k]) <= len(labels), f"{k} {sI+self.dataset_lens[k]} vs. {len(labels)}"
-            labels[sI:(sI+self.dataset_lens[k])] = k
-            sI += self.dataset_lens[k]
-        self.labels = labels
-
-    def __len__(self):
-        return self.num_samples
-
-    def __getitem__(self, index):
-        assert index >= 0 and index < len(self)
-        # find the dataset file we need to go to
-        d_index = np.searchsorted(self.dataset_cumsums, index)
-
-        # edge case, if index is at edge of chunks, move right
-        if index in self.dataset_cumsums:
-            d_index += 1
-
-        assert d_index == self.labels[index], f"{d_index} vs. {self.labels[index]} mismatch for {index}"
-
-        # change index to local dataset index
-        if d_index == 0:
-            local_index = index
-        else:
-            local_index = index - self.dataset_cumsums[d_index - 1]
-        data_bytes = self.chunk_datasets[d_index][local_index]
-        exception_to_catch = UnidentifiedImageError if unidentified_error_available else Exception
-        try:
-            image = Image.open(data_bytes).convert("RGB")
-        except exception_to_catch:
-            image = Image.fromarray(np.ones((224,224,3), dtype=np.uint8)*128)
-            d_index = -1
-
-        # label is the dataset (synset) we indexed into
-        return image, d_index, index
-
-    def __repr__(self):
-        st = f"DiskTarDataset(subdatasets={len(self.dataset_lens)},samples={self.num_samples})"
-        return st
-
-class _TarDataset(object):
-
-    def __init__(self, filename, npy_index_dir, preload=False):
-        # translated from
-        # fbcode/experimental/deeplearning/matthijs/comp_descs/tardataset.lua
-        self.filename = filename
-        self.names = []
-        self.offsets = []
-        self.npy_index_dir = npy_index_dir
-        names, offsets = self.load_index()
-
-        self.num_samples = len(names)
-        if preload:
-            self.data = np.memmap(filename, mode='r', dtype='uint8')
-            self.offsets = offsets
-        else:
-            self.data = None
-
-
-    def __len__(self):
-        return self.num_samples
-
-    def load_index(self):
-        basename = os.path.basename(self.filename)
-        basename = os.path.splitext(basename)[0]
-        names = np.load(os.path.join(self.npy_index_dir, f"{basename}_names.npy"))
-        offsets = np.load(os.path.join(self.npy_index_dir, f"{basename}_offsets.npy"))
-        return names, offsets
-
-    def __getitem__(self, idx):
-        if self.data is None:
-            self.data = np.memmap(self.filename, mode='r', dtype='uint8')
-            _, self.offsets = self.load_index()
-
-        ofs = self.offsets[idx] * 512
-        fsize = 512 * (self.offsets[idx + 1] - self.offsets[idx])
-        data = self.data[ofs:ofs + fsize]
-
-        if data[:13].tostring() == '././@LongLink':
-            data = data[3 * 512:]
-        else:
-            data = data[512:]
-
-        # just to make it more fun a few JPEGs are GZIP compressed...
-        # catch this case
-        if tuple(data[:2]) == (0x1f, 0x8b):
-            s = io.BytesIO(data.tostring())
-            g = gzip.GzipFile(None, 'r', 0, s)
-            sdata = g.read()
-        else:
-            sdata = data.tostring()
-        return io.BytesIO(sdata)
\ No newline at end of file
diff --git a/spaces/tdaslex/README/README.md b/spaces/tdaslex/README/README.md
deleted file mode 100644
index 9a38fd833c44b1e3575dd436bf498a27cd5cd0c0..0000000000000000000000000000000000000000
--- a/spaces/tdaslex/README/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: README
-emoji: 👀
-colorFrom: yellow
-colorTo: indigo
-sdk: static
-pinned: false
----
-
-Edit this `README.md` markdown file to author your organization card 🔥
diff --git a/spaces/terfces0erbo/CollegeProjectV2/ATIR.STRAP.2011.BEAMD.2010 64 Bit.md b/spaces/terfces0erbo/CollegeProjectV2/ATIR.STRAP.2011.BEAMD.2010 64 Bit.md
deleted file mode 100644
index f6c29eb3c4e2495245a15286d8c120cfc0417438..0000000000000000000000000000000000000000
--- a/spaces/terfces0erbo/CollegeProjectV2/ATIR.STRAP.2011.BEAMD.2010 64 Bit.md	
+++ /dev/null
@@ -1,10 +0,0 @@
-<br />
-<p>atir strap 2011 beamd 2010 63 -> f40e7c8ce2 beamd.2010 atir strap 2011 updates build 109 atmel studio 6.0.. atir.strap.2011.beamd.2010. atir strap 2011 updates build 109. atmel studio 6. autonest v9.63 +v9.22. 2 aug 2013. v7.3 atir strap 2011 autoship v9.1. atir strap 2011 beamd 2010 63 - f42d4e2d88 22 mar 2013. archicad libraries graphisoft (2010)3d models. review request #1870 created july 8, 2011 and updated 9 years, 6 months ago. strap.and.v12.5 atir.strap+beamd2010cn atlast.sketchup.v5.232. omega.v63 cadianarch.2008.omega.v21 cadianmech. artlantis.r.v1.12. artsoft mach3 r2.63.beamd 2008.strap 2009.strap & beamd 2010. atpdraw v3.4. autocad.v2011 autodesk autocad civil3d v2010 sp1&sp2 autodesk.autocad. hum aaj pawansut hanuman ki katha sunate hai kumar vishu.mp3</p>
-<p>atir.strap.2011.beamd.2010 1cd. autodesk mudbox v2013 multilanguage win32 1cd. autodesk mudbox v2013 multilanguage win64 1cd. autodesk. strap 2009 & beamd 2008. atir.2010. atir strap 2011 updates build 109.</p>
-<h2>ATIR.STRAP.2011.BEAMD.2010 64 bit</h2><br /><p><b><b>Download File</b> &#10038;&#10038;&#10038; <a href="https://bytlly.com/2uGlFg">https://bytlly.com/2uGlFg</a></b></p><br /><br />
-<p>etir.str.11.01.24.51.35.09. atir.strap.2011.beamd.2010. atir strap 2011 updates build 109. autodesk.etir. atir strap 2011 updates build.. inventor v2010 sp2+sp1 autograph.3.3 automgen v7.100.2010 64bit autodesk.09 autodesk.2010 1cd. ataville fuse.v6.2.2010 1cd autodesk.</p>
-<p>atir.strap.2011.beamd.2010 1cd. autodesk architectural design 2011 architectural design 1cd. autodesk. strap 2009 & beamd 2008. atir. atir strap 2011 updates build 109. atmel studio 6.0 build 1843. atpdraw v3.4. </p>
-<p>atir.strap.2011.beamd.2010 2cd. autodesk architectural design 2011 architectural design 1cd. autodesk. strap 2009 & beamd 2008. atir.2010 1cd. atir strap 2011 updates build 109. atmel studio 6.0 build 1843. atpdraw v3.4. </p>
-<p></p> 899543212b<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/terfces0erbo/CollegeProjectV2/Call Of Duty WWII Digital Deluxe Edition (English Pack Only) 2018 No Survey [PATCHED].md b/spaces/terfces0erbo/CollegeProjectV2/Call Of Duty WWII Digital Deluxe Edition (English Pack Only) 2018 No Survey [PATCHED].md
deleted file mode 100644
index 963118162f58e2630d563eb1874ed0c037934c52..0000000000000000000000000000000000000000
--- a/spaces/terfces0erbo/CollegeProjectV2/Call Of Duty WWII Digital Deluxe Edition (English Pack Only) 2018 No Survey [PATCHED].md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>Call of Duty: WWII Digital Deluxe Edition (English Pack Only) 2018 no survey</h2><br /><p><b><b>Download Zip</b> &#9734; <a href="https://bytlly.com/2uGl51">https://bytlly.com/2uGl51</a></b></p><br /><br />
-<br />
-Download the latest version of IWD (40.5 MB). Call of Death Call of Death Original Game Free Download Game. Call of Death is a game where players and players team up to defeat the best in the Call of Death World Championship. Call of Death is a game where players team up to destroy the best in the world. IWD Keygen Free Download - IWD Keygen can turn any video file into a DVD, simple enough? Very good! For IWD Keygen, select the source file from the movie. " Call of Death Call of Death. " Call of Death. Play games online for free, watch flash games, play the best free online games and much more. Call of Death is a game where players team up to destroy the best in the world. Call of Death is a game where players team up to defeat the best in the Call of Death World Championship. IWD Keygen Free Download - IWD Keygen can turn any video file into a DVD, simple enough? Very good! For IWD Keygen, select the source file from the movie. " Call of Death Call of Death. " Call of Death. Play games online for free, watch flash games, play the best free online games and much more. Call of Death is a game where players team up to destroy the best in the world. Call of Death is a game where players team up to defeat the best in the Call of Death World Championship. Call of Death is a game where players team up to destroy the best in the world. iwd (4764 files) Call of duty 2 main iw 00 iwd download Key code call of. Call Of Duty WWII Digital Deluxe Edition English Pack Only Unlimited. Call Of Death Call Of Death Original Game Free Download Game. Call Of Death is a game where players team up to destroy the best in the world. Call Of Death is a game where players team up to defeat the best in the Call Of Death World Championship. Call of Death is a game where players team up to destroy the best in the world. IWD Keygen Free Download - IWD Keygen can turn any video file into a DVD, simple enough? Very good! For IWD Keygen, select the source file from the movie. " Call of Death Call of Death. " Call of Death. Play games online for free, watch flash games, play the best free online games and much more. Call of Death is a game where players team up to destroy the best in the world. Call of Death is a 4fefd39f24<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/terfces0erbo/CollegeProjectV2/Filma Indian Me Titra Shqip Falas REPACK.md b/spaces/terfces0erbo/CollegeProjectV2/Filma Indian Me Titra Shqip Falas REPACK.md
deleted file mode 100644
index 02b4cb2869128e4165396b4a5566d9afd944ca33..0000000000000000000000000000000000000000
--- a/spaces/terfces0erbo/CollegeProjectV2/Filma Indian Me Titra Shqip Falas REPACK.md	
+++ /dev/null
@@ -1,10 +0,0 @@
-<br />
-<p>gjith disa filma indian me titra shqip e kuajme te me blirimitme te shikojme shqip te te videose,. new porn videos tags film indian me titra shqip you can watch.download xxx film indian me titra shqip mp4 videos. </p>
-<h2>filma indian me titra shqip falas</h2><br /><p><b><b>Download File</b> &#10031;&#10031;&#10031; <a href="https://bytlly.com/2uGkKa">https://bytlly.com/2uGkKa</a></b></p><br /><br />
-<p>filma indian me titra shqip. filma indian me titra shqip - super film pr t mos u humbur - filmat m t bukur me titra shqip. svision hd. 3.74k subscribers. filma me titra shqip - krrish / film indian i plot me titra shqip / full hd / #film #filmaxl. 12,408 views 12,408 views film krrish. filmaon.li - filma dhe seriale me titra shqip hd! netflix, turk, gjerman, rus, kinez, francez, spanjoll. </p>
-<p>filma indian me titra shqip, filma hindi me titra shqip. filma me titra shqip - super film pr t mos u humbur - filmat m t bukur me titra shqip. svision hd. 3.74k subscribers. filmaon.li - filma dhe seriale me titra shqip hd! netflix, turk, gjerman, rus, kinez, francez, spanjoll. </p>
-<p>srvirian.is - filma gjermanca me titra shqip < 13,308 video >. filma me titra shqip - filma e fundit. filma dhe seriale m t fundit me titra shqip. filma e fundit me titra shqip - filmat me titra shqip e fundit m e cilsi hd 720p. u video shqip me titra. </p>
-<p></p>
-<p>filma me titra shqip - 1.38k like - shqip me titra e fundit, shqip me titra. filma dhe seriale m t fundit me titra shqip. filma me titra shqip - filma me titra e fundit. filma me titra shqip - filmat me titra e fundit m e cilsi 720p. filma me titra shqip - film me titra e fundit.. filma e fundit me titra shqip - filmat me titra e fundit m e cilsi hd 720p. filma me titra shqip - filmat me titra e fundit m e cilsi hd 720p.</p> 899543212b<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/terfces0erbo/CollegeProjectV2/FlanJet V1.0.md b/spaces/terfces0erbo/CollegeProjectV2/FlanJet V1.0.md
deleted file mode 100644
index c7cab940d54504a5db61e529430b248ad16c7100..0000000000000000000000000000000000000000
--- a/spaces/terfces0erbo/CollegeProjectV2/FlanJet V1.0.md	
+++ /dev/null
@@ -1,15 +0,0 @@
-<br />
-`<h1>FlanJet v1.0: A New Flanger Effect with Manual Jet or LFO for VirtualDJ</h1>`
-`<p>If you are looking for a new flanger effect to spice up your mixes, you might want to check out FlanJet v1.0, a new plugin created by TexZK for VirtualDJ. FlanJet v1.0 is a flanger effect with manual jet or LFO, which means you can control the intensity and speed of the flanging effect with a simple switch or a slider. FlanJet v1.0 also features feedback, delay depth, LFO length, base delay and stereo effect sliders, as well as quantizable LFO and additive or subtractive feedback modes.</p>`
-`<p>FlanJet v1.0 is compatible with VirtualDJ 8 and above, and it can be downloaded for free from the VirtualDJ addons page[^1^]. To install it, just unzip the file and copy the .dll file to your VirtualDJ plugins folder. You might need to update your system libraries in order to make it work properly[^1^]. FlanJet v1.0 is a great addition to your VirtualDJ effects arsenal, as it can create a wide range of flanging sounds, from subtle to extreme, depending on your settings and preferences.</p>
-<h2>FlanJet v1.0</h2><br /><p><b><b>DOWNLOAD</b> &mdash;&mdash;&mdash;>>> <a href="https://bytlly.com/2uGm4m">https://bytlly.com/2uGm4m</a></b></p><br /><br />`
-`<p>FlanJet v1.0 is not the first flanger effect created by TexZK, who is also the author of other popular plugins such as High Quality Flanger v2, EchoOut v2 and ReverbOut v2. TexZK is a PRO Infinity member of VirtualDJ since 2005, and he has been developing plugins for VirtualDJ using his own audio library[^2^]. He says that FlanJet v1.0 is a brand new flanger, completely rewritten from scratch, that sounds exactly like a flanger in other DAWs, with real feedback control[^2^].</p>`
-`<p>If you want to learn more about FlanJet v1.0, you can visit the VirtualDJ forums[^2^], where TexZK and other users have posted their feedback and suggestions about the plugin. You can also watch some videos of FlanJet v1.0 in action on YouTube or Coub[^3^]. FlanJet v1.0 is a versatile and powerful flanger effect that can enhance your mixes with a touch of jet or LFO. Try it out today and let us know what you think!</p>`
-
-`<p>FlanJet v1.0 is not the only flanger effect available for VirtualDJ. There are other plugins that offer similar or different features, such as Flanger v1.0, Flanger v2.0, Flanger v3.0, Flanger v4.0, Flanger v5.0 and Flanger v6.0, which are all built-in effects that come with VirtualDJ. There are also third-party plugins such as FlanChorus v1.0, FlanDelay v1.0 and FlanSweep v1.0, which combine flanging with chorus, delay and filter effects respectively.</p>`
-`<p>Flanging is a sound effect that occurs when two identical signals are mixed together, with one signal slightly delayed or modulated by a low-frequency oscillator (LFO). This creates a comb filter effect that produces a sweeping sound that varies in pitch and phase. Flanging is often used to create a psychedelic or spacey sound on guitars, vocals, drums and other instruments.</p>`
-`<p>Flanging was originally created in the 1960s by recording engineers who manually manipulated two tape machines playing the same track in sync. By slightly varying the speed of one tape machine, they created the flanging effect. The term "flanging" comes from the act of pressing a finger on the flange or rim of one of the tape reels to slow it down.</p>
-<p></p>`
-`<p>Today, flanging can be easily achieved with digital effects processors or plugins such as FlanJet v1.0. FlanJet v1.0 allows you to control various parameters of the flanging effect, such as feedback, delay depth, LFO length, base delay and stereo effect. You can also switch between manual jet or LFO mode, which gives you more flexibility and creativity in applying the effect.</p>` d5da3c52bf<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/thinh-researcher/cord-v2/app.py b/spaces/thinh-researcher/cord-v2/app.py
deleted file mode 100644
index 51d48aa833d0e6b7c0063f4a8124cd8bc3b90761..0000000000000000000000000000000000000000
--- a/spaces/thinh-researcher/cord-v2/app.py
+++ /dev/null
@@ -1,53 +0,0 @@
-"""
-Donut
-Copyright (c) 2022-present NAVER Corp.
-MIT License
-
-https://github.com/clovaai/donut
-"""
-import gradio as gr
-import torch
-from PIL import Image
-
-from donut import DonutModel
-
-
-def demo_process(input_img):
-    global pretrained_model, task_prompt, task_name
-    # input_img = Image.fromarray(input_img)
-    output = pretrained_model.inference(image=input_img, prompt=task_prompt)[
-        "predictions"
-    ][0]
-    return output
-
-
-task_prompt = f"<s_cord-v2>"
-
-pretrained_model = DonutModel.from_pretrained(
-    "naver-clova-ix/donut-base-finetuned-cord-v2"
-)
-# pretrained_model: DonutModel = DonutModel.from_pretrained(
-#     "result", local_files_only=True
-# )
-pretrained_model.eval()
-
-demo = gr.Interface(
-    fn=demo_process,
-    inputs=gr.inputs.Image(type="pil"),
-    outputs="json",
-    title=f"Donut 🍩 demonstration for `cord-v2` task",
-    description="""This model is trained with 800 Indonesian receipt images of CORD dataset. <br>
-Demonstrations for other types of documents/tasks are available at https://github.com/clovaai/donut <br>
-More CORD receipt images are available at https://huggingface.co/datasets/naver-clova-ix/cord-v2
-
-More details are available at:
-- Paper: https://arxiv.org/abs/2111.15664
-- GitHub: https://github.com/clovaai/donut""",
-    examples=[
-        ["sample_image_cord_test_receipt_00004.png"],
-        ["sample_image_cord_test_receipt_00012.png"],
-    ],
-    cache_examples=False,
-)
-
-demo.launch(server_name="0.0.0.0")
diff --git a/spaces/ticomspire/turkey-syria-earthquake-tweets/logs/CarX Street Mod APK  OBB Enjoy Unlimited Money and Cars on Android.md b/spaces/ticomspire/turkey-syria-earthquake-tweets/logs/CarX Street Mod APK  OBB Enjoy Unlimited Money and Cars on Android.md
deleted file mode 100644
index ab3ad6f277cba432c35089a3ba06a89555c0fa8a..0000000000000000000000000000000000000000
--- a/spaces/ticomspire/turkey-syria-earthquake-tweets/logs/CarX Street Mod APK  OBB Enjoy Unlimited Money and Cars on Android.md	
+++ /dev/null
@@ -1,83 +0,0 @@
-
-<h1>CarX Street Android Mod APK OBB: How to Download and Install the Latest Version</h1>
- <p>If you are a fan of racing games, you might have heard of CarX Street, a realistic and immersive game that lets you drive various sports cars on different tracks and modes. But did you know that you can enhance your gaming experience by using CarX Street Mod APK OBB? In this article, we will tell you what CarX Street is, why you should use the modded version, and how to download and install it on your Android device.</p>
-<h2>carx street android mod apk obb</h2><br /><p><b><b>Download</b> &rarr; <a href="https://bltlly.com/2uOl8F">https://bltlly.com/2uOl8F</a></b></p><br /><br />
- <h2>What is CarX Street?</h2>
- <p>CarX Street is a racing game developed by CarX Technologies, LLC, the same company behind other popular games like CarX Drift Racing and CarX Highway Racing. The game features stunning graphics, realistic physics, and smooth controls that make you feel like you are driving a real car. You can choose from a variety of cars, from classic muscle cars to modern supercars, and customize them with different parts, colors, and stickers. You can also select from different tracks, such as city streets, highways, or off-road terrains, and compete in various modes, such as time trial, drag race, or drift challenge. You can also play online with other players from around the world and show off your skills on the leaderboards.</p>
- <h2>Why use CarX Street Mod APK OBB?</h2>
- <p>CarX Street is a free-to-play game, but it also has some in-app purchases that require real money. For example, you need to spend coins or diamonds to buy new cars or upgrade them. You also need to watch ads or complete tasks to earn more resources. These can be annoying and limit your enjoyment of the game. That's why many players prefer to use CarX Street Mod APK OBB, which is a modified version of the game that gives you unlimited money and resources. With this mod, you can access all the cars and tracks without spending a dime. You can also enjoy the game without ads or restrictions. This way, you can have more fun and freedom in playing CarX Street.</p>
- <h2>How to download and install CarX Street Mod APK OBB?</h2>
- <p>Downloading and installing CarX Street Mod APK OBB is not difficult, but you need to follow some steps carefully. Here are the steps you need to take:</p>
- <h3>Step 1: Find a reliable source for the modded files</h3>
- <p>The first thing you need to do is to find a trustworthy website that provides the modded files for CarX Street. You can search online or use this link as an example. Make sure that the website is safe and secure, and that the files are updated and compatible with your device. You can also read the reviews and comments from other users to see if the mod works well.</p>
- <h3>Step 2: Download the APK and OBB files to your device</h3>
- <p>The next thing you need to do is to download the APK and OBB files to your device. The APK file is the application file that installs the game, while the OBB file is the data file that contains the game content. You can download them from the website you chose in step 1, or use this link as an example. Make sure that you have enough storage space on your device, and that you have a stable internet connection. You can also use a download manager app to speed up the process.</p>
- <h3>Step 3: Enable unknown sources in your settings</h3>
- <p>Before you can install the APK file, you need to enable unknown sources in your settings. This allows you to install apps from sources other than the Google Play Store. To do this, go to your device settings, then security, then unknown sources, and toggle it on. You may also see a pop-up message asking for your permission, just tap on OK or Allow. This step may vary depending on your device model and Android version, so check your manual if you are not sure.</p>
- <h3>Step 4: Install the APK file and extract the OBB file to the Android/obb folder</h3>
- <p>Now you are ready to install the APK file and extract the OBB file to the Android/obb folder. To do this, locate the APK file in your downloads folder or wherever you saved it, and tap on it. You may see a warning message saying that the app may harm your device, just ignore it and tap on Install. Wait for the installation to finish, but do not open the game yet. Next, locate the OBB file, which should be in a zip or rar format, and extract it using a file manager app or a zip extractor app. You should see a folder named com.carxtech.street or something similar. Copy or move this folder to the Android/obb folder in your internal storage. If you don't have an obb folder, create one.</p>
-<p>carx street racing mod apk + obb download<br />
-carx street unlimited money mod apk obb<br />
-carx street latest version mod apk obb<br />
-carx street hack mod apk obb free<br />
-carx street offline mod apk obb<br />
-carx street drift mod apk obb data<br />
-carx street 0.9.2 mod apk obb<br />
-carx street android 1 mod apk obb<br />
-carx street rexdl mod apk obb<br />
-carx street revdl mod apk obb<br />
-carx street mod apk obb file download<br />
-carx street mod apk obb highly compressed<br />
-carx street mod apk obb mega link<br />
-carx street mod apk obb google drive<br />
-carx street mod apk obb mediafire<br />
-carx street mod apk obb android oyun club<br />
-carx street mod apk obb no root<br />
-carx street mod apk obb unlimited coins<br />
-carx street mod apk obb unlocked cars<br />
-carx street mod apk obb vip unlocked<br />
-carx street mod apk obb full version<br />
-carx street mod apk obb gameplay<br />
-carx street mod apk obb graphics settings<br />
-carx street mod apk obb new update<br />
-carx street mod apk obb best cars<br />
-carx street mod apk obb cheat menu<br />
-carx street mod apk obb easy install<br />
-carx street mod apk obb for android 11<br />
-carx street mod apk obb for android 10<br />
-carx street mod apk obb for android 9<br />
-carx street mod apk obb for android 8<br />
-carx street mod apk obb for android 7<br />
-carx street mod apk obb for android 6<br />
-carx street mod apk obb for android 5<br />
-carx street mod apk obb for android 4.4.4 kitkat <br />
-carx street mod apk obb low mb size <br />
-carx street mod apk obb no ads <br />
-carx street mod apk obb premium features <br />
-carx street mod apk obb pro version <br />
-carx street mod apk obb real physics <br />
-carx street mod apk obb realistic graphics <br />
-carx street mod apk obb smooth controls <br />
-carx street mod apk obb sound effects <br />
-carx street mod apk obb support all devices <br />
-carx street mod apk obb tips and tricks <br />
-carx street mod apk obb tutorial guide <br />
-carx street mod apk obb video review <br />
-carx street mod apk obb working 100%</p>
- <h3>Step 5: Launch the game and enjoy</h3>
- <p>Congratulations, you have successfully downloaded and installed CarX Street Mod APK OBB on your Android device. Now you can launch the game from your app drawer or home screen, and enjoy playing with unlimited money and resources. You can also check out the settings and options to customize your gameplay preferences.</p>
- <h2>Conclusion</h2>
- <p>CarX Street Mod APK OBB is a great way to experience the game with more fun and freedom. You can unlock all the cars and tracks, upgrade them as you wish, and play without ads or restrictions. You can also compete with other players online and show off your skills. To download and install CarX Street Mod APK OBB, just follow the steps above and make sure that you use a reliable source for the modded files. Remember to always backup your data before installing any mod, and to disable unknown sources after installing it.</p>
- <h2>FAQs</h2>
- <h3>Is CarX Street Mod APK OBB safe to use?</h3>
- <p>CarX Street Mod APK OBB is generally safe to use, as long as you download it from a trusted website and scan it for viruses or malware before installing it. However, there is always a risk of damaging your device or losing your data when using any mod, so use it at your own discretion.</p>
- <h3>Will I get banned for using CarX Street Mod APK OBB?</h3>
- <p>There is a possibility of getting banned for using CarX Street Mod APK OBB, especially if you play online with other players who may report you for cheating or hacking. To avoid this, you can play offline or use a VPN app to hide your IP address. You can also create a new account or use a guest account to play with the mod.</p>
- <h3>How do I update CarX Street Mod APK OBB?</h3>
- <p>To update CarX Street Mod APK OBB, you need to download the latest version of the modded files from the same website you used before, or find another website that provides them. Then, uninstall the old version of the game from your device, and install the new version following the same steps as before. Make sure that you backup your data before updating, as you may lose your progress or settings.</p>
- <h3>Can I play CarX Street Mod APK OBB offline?</h3>
- <p>Yes, you can play CarX Street Mod APK OBB offline without an internet connection. However, some features may not work properly, such as online multiplayer or leader boards. You may also miss some updates or events that require an internet connection. To play online, you need to turn on your Wi-Fi or mobile data, and make sure that you have a stable connection.</p>
- <h3>Can I use CarX Street Mod APK OBB with other mods?</h3>
- <p>It depends on the compatibility and functionality of the other mods you want to use with CarX Street Mod APK OBB. Some mods may work well together, while others may cause conflicts or errors. To avoid any problems, you should only use one mod at a time, or use a mod menu app that allows you to switch between different mods easily. You should also check the reviews and comments from other users who have tried using the mods together, and see if they have any issues or tips.</p> 401be4b1e0<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/ticomspire/turkey-syria-earthquake-tweets/logs/Download Endless Temple Crazy Run MOD APK and Explore the Mysterious Temples.md b/spaces/ticomspire/turkey-syria-earthquake-tweets/logs/Download Endless Temple Crazy Run MOD APK and Explore the Mysterious Temples.md
deleted file mode 100644
index 28a10258378ebf43d28979692d0a2f4867f26ed0..0000000000000000000000000000000000000000
--- a/spaces/ticomspire/turkey-syria-earthquake-tweets/logs/Download Endless Temple Crazy Run MOD APK and Explore the Mysterious Temples.md	
+++ /dev/null
@@ -1,89 +0,0 @@
-<br />
-<h1>Endless Temple Crazy Run Mod APK Download: A Fun and Exciting Arcade Game</h1>
-<p>Do you love running games that test your reflexes and skills? Do you want to experience the thrill of escaping from ancient temples filled with traps and dangers? If yes, then you should try Endless Temple Crazy Run, a fun and exciting arcade game that will keep you hooked for hours. In this game, you have to run as fast as you can, avoid obstacles, collect coins and gems, and use power-ups to boost your performance. You can also unlock different characters and customize them with various outfits and accessories. Endless Temple Crazy Run is a game that will challenge you, entertain you, and make you feel like a real adventurer.</p>
-<h2>What is Endless Temple Crazy Run?</h2>
-<p>Endless Temple Crazy Run is a arcade game developed by \uE000Mod\uE001droid Games, a popular developer of modded games. It is inspired by the famous Temple Run series, but with more features and improvements. The game has a simple gameplay: you have to swipe left or right to change lanes, swipe up to jump, swipe down to slide, and tilt your device to move sideways. You have to avoid obstacles such as spikes, fireballs, gaps, walls, and more. You also have to collect coins and gems along the way, which you can use to buy power-ups and unlock new characters. The game has an endless mode, where you can run as far as you can and compete with other players on the leaderboards. The game also has a level mode, where you have to complete different missions and challenges in various temples.</p>
-<h2>endless temple crazy run mod apk download</h2><br /><p><b><b>Download Zip</b> &#9733;&#9733;&#9733;&#9733;&#9733; <a href="https://bltlly.com/2uOpSg">https://bltlly.com/2uOpSg</a></b></p><br /><br />
-<h3>Features of Endless Temple Crazy Run</h3>
-<h4>Stunning graphics and sound effects</h4>
-<p>One of the best features of Endless Temple Crazy Run is its stunning graphics and sound effects. The game has a 3D design that makes you feel like you are in a real temple. The game also has realistic animations and physics that make the running experience more immersive. The game also has amazing sound effects that add to the atmosphere of the game. You can hear the footsteps of your character, the roar of the fireballs, the clink of the coins, and more. The game also has a catchy background music that matches the theme of the game.</p>
-<h4>Various characters and power-ups</h4>
-<p>Another feature of Endless Temple Crazy Run is its variety of characters and power-ups. The game has over 20 characters that you can unlock and play with. Each character has its own personality and style. You can also customize your character with different outfits and accessories that suit your preference. The game also has over 10 power-ups that you can use to enhance your running performance. Some of the power-ups are magnet, shield, jetpack, coin multiplier, speed boost, and more. You can buy power-ups with coins or gems, or find them randomly on the road.</p>
-<h4>Challenging levels and obstacles</h4>
-<p>A feature that makes Endless Temple Crazy Run more fun and exciting is its challenging levels and obstacles. The game has over 100 levels that you can play in the level mode. Each level has a different mission and difficulty that you have to complete. Some of the missions are collecting a certain number of coins or gems, reaching a certain distance, or escaping from a boss. The game also has various obstacles that make the running more challenging. Some of the obstacles are spikes, fireballs, gaps, walls, statues, and more. You have to be quick and alert to avoid them and survive.</p>
-<h4>Leaderboards and achievements</h4>
-<p>A feature that makes Endless Temple Crazy Run more competitive and rewarding is its leaderboards and achievements. The game has a global leaderboard that shows the rankings of the players based on their scores. You can see your rank and compare it with other players around the world. You can also see the ranks of your friends and challenge them to beat your score. The game also has over 50 achievements that you can unlock by completing various tasks. Some of the achievements are running a certain distance, collecting a certain number of coins or gems, using a certain number of power-ups, and more. You can earn coins and gems as rewards for unlocking achievements.</p>
-<h3>How to download and install Endless Temple Crazy Run Mod APK?</h3>
-<p>If you want to download and install Endless Temple Crazy Run Mod APK, you have to follow these simple steps:</p>
-<h4>Step 1: Download the mod apk file from a trusted source</h4>
-<p>The first step is to download the mod apk file from a trusted source. You can use the link below to download the latest version of Endless Temple Crazy Run Mod APK. The file size is about 50 MB and it is safe and virus-free.</p>
-<h4>Step 2: Enable unknown sources on your device</h4>
-<p>The second step is to enable unknown sources on your device. This is necessary to install apps from sources other than the Google Play Store. To do this, you have to go to your device settings, then security, then unknown sources, and then toggle it on. This will allow you to install the mod apk file.</p>
-<h4>Step 3: Install the mod apk file and enjoy the game</h4>
-<p>The third step is to install the mod apk file and enjoy the game. To do this, you have to locate the downloaded file on your device storage, then tap on it, then follow the instructions on the screen. Once the installation is done, you can open the game and start playing with unlimited coins and gems, unlocked characters and power-ups, and no ads.</p>
-<p>endless temple crazy run mod apk free download<br />
-endless temple crazy run mod apk unlimited money<br />
-endless temple crazy run mod apk latest version<br />
-endless temple crazy run mod apk android 1<br />
-endless temple crazy run mod apk hack<br />
-endless temple crazy run mod apk offline<br />
-endless temple crazy run mod apk no ads<br />
-endless temple crazy run mod apk revdl<br />
-endless temple crazy run mod apk 2023<br />
-endless temple crazy run mod apk rexdl<br />
-download endless temple crazy run mod apk for pc<br />
-download endless temple crazy run mod apk for ios<br />
-download endless temple crazy run mod apk for android<br />
-download endless temple crazy run mod apk 1.3.4<br />
-download endless temple crazy run mod apk unlocked<br />
-download endless temple crazy run mod apk online<br />
-download endless temple crazy run mod apk full version<br />
-download endless temple crazy run mod apk from apkpure<br />
-download endless temple crazy run mod apk from uptodown<br />
-download endless temple crazy run mod apk from happy mod<br />
-how to download endless temple crazy run mod apk<br />
-how to install endless temple crazy run mod apk<br />
-how to play endless temple crazy run mod apk<br />
-how to update endless temple crazy run mod apk<br />
-how to get endless temple crazy run mod apk<br />
-best site to download endless temple crazy run mod apk<br />
-best way to download endless temple crazy run mod apk<br />
-best source to download endless temple crazy run mod apk<br />
-best app to download endless temple crazy run mod apk<br />
-best link to download endless temple crazy run mod apk<br />
-is it safe to download endless temple crazy run mod apk<br />
-is it legal to download endless temple crazy run mod apk<br />
-is it possible to download endless temple crazy run mod apk<br />
-is it easy to download endless temple crazy run mod apk<br />
-is it worth to download endless temple crazy run mod apk<br />
-why download endless temple crazy run mod apk<br />
-why choose endless temple crazy run mod apk<br />
-why play endless temple crazy run mod apk<br />
-why install endless temple crazy run mod apk<br />
-why update endless temple crazy run mod apk</p>
-<h3>Why should you download Endless Temple Crazy Run Mod APK?</h3>
-<p>You should download Endless Temple Crazy Run Mod APK for these reasons:</p>
-<h4>Unlimited coins and gems</h4>
-<p>With Endless Temple Crazy Run Mod APK, you will have unlimited coins and gems that you can use to buy power-ups and unlock new characters. You will not have to worry about running out of coins or gems or spending real money to get them. You can enjoy the game without any limitations.</p>
-<h4>Unlocked all characters and power-ups</h4>
-<p>With Endless Temple Crazy Run Mod APK, you will have all the characters and power-ups unlocked from the start. You will not have to collect coins or gems or complete levels to unlock them. You can choose any character you want and use any power-up you need. You can customize your character with different outfits and accessories that suit your style.</p>
-<h4>No ads and no root required</h4>
-<p>With Endless Temple Crazy Run Mod APK, you will not see any ads that interrupt your gameplay or annoy you. You will also not need to root your device to install or play the game. You can enjoy the game without any hassle or risk.</p>
-<h2>Conclusion</h2>
-<p>Endless Temple Crazy Run is a fun and exciting arcade game that will test your reflexes and skills. It has stunning graphics and sound effects, various characters and power-ups, challenging levels and obstacles, leaderboards and achievements, and more. It is a game that will keep you hooked for hours. If you want to enjoy the game with unlimited coins and gems, unlocked characters and power-ups, no ads, and no root required, you should download Endless Temple Crazy Run Mod APK from the link below. It is a modded version of the game that will give you all these benefits for free. Download it now and start running!</p>
-<h2>FAQs</h2>
-<p>Here are some frequently asked questions about Endless Temple Crazy Run Mod APK:</p>
-<ul>
-<li><b>Q: Is Endless Temple Crazy Run Mod APK safe to download?</b></li>
-<li>A: Yes, it is safe to download. It is a virus-free file that does not contain any malware or spyware. It also does not require any permissions or access to your device data.</li>
-<li><b>Q: Is Endless Temple Crazy Run Mod APK compatible with my device?</b></li>
-<li>A: Yes, it is compatible with most Android devices that run on Android 4.1 or higher. It also supports different screen sizes and resolutions.</li>
-<li><b>Q: How can I update Endless Temple Crazy Run Mod APK?</b></li>
-<li>A: You can update Endless Temple Crazy Run Mod APK by downloading the latest version from the same source you downloaded the previous version. You can also check for updates within the game settings. However, you may lose your modded features if you update the game from the Google Play Store.</li>
-<li><b>Q: Can I play Endless Temple Crazy Run Mod APK online with other players?</b></li>
-<li>A: Yes, you can play Endless Temple Crazy Run Mod APK online with other players. You can connect your game to your Facebook account and see your friends' scores and ranks on the leaderboards. You can also invite your friends to play with you and challenge them to beat your score.</li>
-<li><b>Q: Can I play Endless Temple Crazy Run Mod APK offline without internet connection?</b></li>
-<li>A: Yes, you can play Endless Temple Crazy Run Mod APK offline without internet connection. You can enjoy the game in the endless mode or the level mode without any interruption. However, you may not be able to access some features that require internet connection, such as leaderboards, achievements, and social media integration.</li>
-</ul></p> 401be4b1e0<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/ticomspire/turkey-syria-earthquake-tweets/logs/Download Google Play Store on Xiaomi Redmi 9a with Google Installer APK.md b/spaces/ticomspire/turkey-syria-earthquake-tweets/logs/Download Google Play Store on Xiaomi Redmi 9a with Google Installer APK.md
deleted file mode 100644
index c642d2b0da805b58ec84597c17394f58ac079c50..0000000000000000000000000000000000000000
--- a/spaces/ticomspire/turkey-syria-earthquake-tweets/logs/Download Google Play Store on Xiaomi Redmi 9a with Google Installer APK.md	
+++ /dev/null
@@ -1,175 +0,0 @@
-<br />
-<h1>How to Download Google Play Store in Redmi 9A</h1>
-<p>If you are a proud owner of a Redmi 9A smartphone, you might be wondering how to download and install Google Play Store on your device. In this article, we will show you everything you need to know about Google Play Store, why you might need it, and how to get it on your Redmi 9A.</p>
-<h2>how can i download google play store in redmi 9a</h2><br /><p><b><b>Download File</b> &rArr; <a href="https://bltlly.com/2uOnCj">https://bltlly.com/2uOnCj</a></b></p><br /><br />
-<h2>What is Redmi 9A?</h2>
-<p>Redmi 9A is an entry-level smartphone that was launched by Xiaomi in June 2020. It features a 6.53-inch HD+ display, a MediaTek Helio G25 chipset, a 13-megapixel rear camera, a 5-megapixel front camera, a 5000 mAh battery, and up to 6 GB of RAM and 128 GB of storage . It runs on Android 10 operating system with MIUI 12 software.</p>
-<p>The Redmi 9A is available in different colors such as Granite Gray, Peacock Green, and Sky Blue. It has a starting price of $69.50 in the US, £83.00 in the UK, €74.35 in Europe, and ₹6,999 in India.</p>
-<h2>What is Google Play Store?</h2>
-<p>Google Play Store is an app that allows you to download and install apps, games, and digital content for your Android device. It also provides updates, reviews, ratings, recommendations, and security features for your apps and games.</p>
-<p>How can i download google play store in redmi 9a without pc<br />
-How can i download google play store in redmi 9a miui 12<br />
-How can i download google play store in redmi 9a step by step<br />
-How can i download google play store in redmi 9a youtube<br />
-How can i download google play store in redmi 9a apk<br />
-How can i download google play store in redmi 9a quora<br />
-How can i download google play store in redmi 9a india<br />
-How can i download google play store in redmi 9a easily<br />
-How can i download google play store in redmi 9a latest version<br />
-How can i download google play store in redmi 9a free<br />
-How can i download google play store in redmi 9a online<br />
-How can i download google play store in redmi 9a fast<br />
-How can i download google play store in redmi 9a video<br />
-How can i download google play store in redmi 9a manually<br />
-How can i download google play store in redmi 9a official<br />
-How can i download google play store in redmi 9a without root<br />
-How can i download google play store in redmi 9a miui 11<br />
-How can i download google play store in redmi 9a tutorial<br />
-How can i download google play store in redmi 9a reddit<br />
-How can i download google play store in redmi 9a app<br />
-How can i download google play store in redmi 9a china<br />
-How can i download google play store in redmi 9a simple<br />
-How can i download google play store in redmi 9a guide<br />
-How can i download google play store in redmi 9a update<br />
-How can i download google play store in redmi 9a safe<br />
-How can i download google play store in redmi 9a without vpn<br />
-How can i download google play store in redmi 9a miui 10<br />
-How can i download google play store in redmi 9a tips<br />
-How can i download google play store in redmi 9a forum<br />
-How can i download google play store in redmi 9a best way<br />
-How can i download google play store in redmi 9a new<br />
-How can i download google play store in redmi 9a quick<br />
-How can i download google play store in redmi 9a review<br />
-How can i download google play store in redmi 9a easy method<br />
-How can i download google play store in redmi 9a solution<br />
-How can i download google play store in redmi 9a without account<br />
-How can i download google play store in redmi 9a miui 13<br />
-How can i download google play store in redmi 9a trick<br />
-How can i download google play store in redmi 9a blog<br />
-How can i download google play store in redmi 9a original<br />
-How can i download google play store in redmi 9a no root<br />
-How can i download google play store in redmi 9a miui version<br />
-How can i download google play store in redmi 9a help<br />
-How can i download google play store in redmi 9a install<br />
-How can i download google play store in redmi 9a working method<br />
-How can i download google play store in redmi 9a without password<br />
-How can i download google play store in redmi 9a miui global rom</p>
-<p>Google Play Store is one of the most popular and trusted sources of Android apps and games. It has over three million apps and games to choose from. It also offers movies, TV shows, books, music, and podcasts for your entertainment. It also supports in-app purchases, subscriptions, and Google Play Pass.</p>
-<h2>Why do you need Google Play Store in Redmi 9A?</h2>
-<p>While most Redmi 9A devices come with Google Play Store pre-installed, some variants may not have it due to regional restrictions or other reasons. For example, if you bought your Redmi 9A from China, you might not have Google Play Store on your device. This means that you will not be able to access the vast library of apps and games that Google Play Store offers.</p>
-<p>Therefore, you might want to download and install Google Play Store on your Redmi 9A manually. This will allow you to enjoy the benefits of Google Play Store, such as:</p>
-<ul>
-<li>Accessing millions of apps and games for your Android device.</li>
-<li>Getting updates, reviews, ratings, and recommendations for your apps and games.</li>
-<li>Downloading and installing digital content such as movies, TV shows, books, music, and podcasts.</li>
-<li>Using in-app purchases, subscriptions, and Google Play Pass for more features and content.</li>
-<li>Protecting your device from malware and viruses with Google Play Protect.</li>
-</ul>
-<h2>How to check if your Redmi 9A has Google Play Store?</h2>
-<p>Before you proceed to download and install Google Play Store on your Redmi 9A, you should first check if your device already has it or not. To do this, follow these simple steps:</p>
-<ol>
-<li>Swipe up from the bottom of your screen to open the app drawer.</li>
-<li>Look for the Google Play Store icon. It is a white triangle with a colorful play button inside it.</li>
-<li>If you see the Google Play Store icon, tap on it to open it. This means that your device already has Google Play Store installed.</li>
-<li>If you do not see the Google Play Store icon, this means that your device does not have Google Play Store installed. You will need to download and install it manually using one of the methods below.</li>
-</ol>
-<h2>How to download and install Google Play Store in Redmi 9A?</h2>
-<p>There are different methods to download and install Google Play Store in Redmi 9A. However, before you try any of them, you should make sure that your device meets the following requirements:</p>
-<ul>
-<li>Your device is running on Android 10 or higher with MIUI 12 or higher software.</li>
-<li>Your device has enough storage space to download and install the Google Play Store app.</li>
-<li>Your device is connected to a stable Wi-Fi or mobile data network.</li>
-<li>Your device has enabled the option to install apps from unknown sources. To do this, go to Settings > Apps > Manage apps > More settings > Install unknown apps > APKMirror Installer (or any other app that you will use to install Google Play Store) > Allow from this source.</li>
-</ul>
-<p>Once you have met these requirements, you can choose one of the following methods to download and install Google Play Store in Redmi 9A:</p> <h3>Method 1: Using APKMirror Installer app</h3>
-<p>This method involves using an app called APKMirror Installer, which allows you to install APK files from APKMirror website, a trusted source of Android apps and games. To use this method, follow these steps:</p>
-<h4>Step 1: Download APKMirror Installer app from Google Play Store</h4>
-<p>If you do not have Google Play Store on your device, you can download the APKMirror Installer app from other sources, such as the official website or other app stores. However, if you have Google Play Store on your device, you can download the APKMirror Installer app from there. To do this, follow these steps:</p>
-<ol>
-<li>Open Google Play Store on your device.</li>
-<li>Search for APKMirror Installer in the search bar.</li>
-<li>Select the app from the search results and tap on Install.</li>
-<li>Wait for the app to download and install on your device.</li>
-</ol>
-<h4>Step 2: Download Google Play Store APK from APKMirror website</h4>
-<p>Once you have installed the APKMirror Installer app on your device, you need to download the Google Play Store APK file from the APKMirror website. To do this, follow these steps:</p>
-<ol>
-<li>Open a web browser on your device and go to <a href="">https://www.apkmirror.com/</a>.</li>
-<li>Search for Google Play Store in the search bar.</li>
-<li>Select the latest version of Google Play Store from the search results and tap on Download APK.</li>
-<li>Wait for the APK file to download on your device.</li>
-</ol>
-<h4>Step 3: Install Google Play Store APK using APKMirror Installer app</h4>
-<p>Once you have downloaded the Google Play Store APK file on your device, you need to install it using the APKMirror Installer app. To do this, follow these steps:</p>
-<ol>
-<li>Open the APKMirror Installer app on your device.</li>
-<li>Tap on Browse files and locate the Google Play Store APK file that you downloaded.</li>
-<li>Select the file and tap on Install package.</li>
-<li>Follow the instructions on the screen to install Google Play Store on your device.</li>
-</ol> <h3>Method 2: Using a file browser app</h3>
-<p>This method involves using a file browser app, which allows you to access and manage the files and folders on your device. You can use any file browser app that you prefer, such as Files by Google, ES File Explorer, or Solid Explorer. To use this method, follow these steps:</p>
-<h4>Step 1: Download a file browser app from Google Play Store or other sources</h4>
-<p>If you do not have Google Play Store on your device, you can download a file browser app from other sources, such as the official website or other app stores. However, if you have Google Play Store on your device, you can download a file browser app from there. To do this, follow these steps:</p>
-<ol>
-<li>Open Google Play Store on your device.</li>
-<li>Search for a file browser app in the search bar.</li>
-<li>Select the app from the search results and tap on Install.</li>
-<li>Wait for the app to download and install on your device.</li>
-</ol>
-<h4>Step 2: Download Google Play Store APK from APKMirror website or other sources</h4>
-<p>Once you have installed a file browser app on your device, you need to download the Google Play Store APK file from the APKMirror website or other sources. To do this, follow these steps:</p>
-<ol>
-<li>Open a web browser on your device and go to <a href="">https://www.apkmirror.com/</a> or any other website that offers Google Play Store APK files.</li>
-<li>Search for Google Play Store in the search bar.</li>
-<li>Select the latest version of Google Play Store from the search results and tap on Download APK.</li>
-<li>Wait for the APK file to download on your device.</li>
-</ol>
-<h4>Step 3: Install Google Play Store APK using a file browser app</h4>
-<p>Once you have downloaded the Google Play Store APK file on your device, you need to install it using a file browser app. To do this, follow these steps:</p>
-<ol>
-<li>Open the file browser app on your device.</li>
-<li>Navigate to the folder where you saved the Google Play Store APK file.</li>
-<li>Select the file and tap on Install.</li>
-<li>Follow the instructions on the screen to install Google Play Store on your device.</li>
-</ol>
-<h2>How to update Google Play Store in Redmi 9A?</h2>
-<p>Once you have installed Google Play Store on your Redmi 9A, you should keep it updated to enjoy the latest features and security improvements. To update Google Play Store in Redmi 9A, follow these steps:</p>
-<ol>
-<li>Open Google Play Store on your device.</li>
-<li>Tap on the menu icon (three horizontal lines) in the top left corner of the screen.</li>
-<li>Select Settings from the menu.</li>
-<li>Scroll down and tap on About > Play Store version.</li>
-<li>If there is an update available, tap on Update to download and install it. If not, you will see a message saying that Google Play Store is up to date.</li>
-</ol>
- <h2>Conclusion</h2>
- <p>In this article, we have shown you how to download and install Google Play Store in Redmi 9A using two different methods. We have also shown you how to check if your device already has Google Play Store or not, and how to update it once it is installed. We hope that this article has been helpful and informative for you. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading!</p>
- <h2>Frequently Asked Questions</h2>
- <p>Here are some of the most common questions that people ask about downloading and installing Google Play Store in Redmi 9A:</p>
- <h3>Q: Is it safe to download and install Google Play Store in Redmi 9A?</h3>
- <p>A: Yes, it is safe to download and install Google Play Store in Redmi 9A as long as you use trusted sources such as APKMirror website or other reputable websites. You should also make sure that your device meets the requirements and enables the option to install apps from unknown sources before proceeding with the installation.</p>
- <h3>Q: Will downloading and installing Google Play Store in Redmi 9A void my warranty?</h3>
- <p>A: No, downloading and installing Google Play Store in Redmi 9A will not void your warranty as long as you do not root your device or modify its software in any way. However, if you encounter any problems with your device after installing Google Play Store, you should contact Xiaomi customer service for assistance.</p>
- <h3>Q: Can I uninstall Google Play Store from Redmi 9A if I don't want it anymore?</h3>
- <p>A: Yes, you can uninstall Google Play Store from Redmi 9A if you don't want it anymore. To do this, follow these steps:</p>
-<ol>
-<li>Open the file browser app on your device.</li>
-<li>Navigate to the folder where you installed the Google Play Store APK file.</li>
-<li>Select the file and tap on Uninstall.</li>
-<li>Follow the instructions on the screen to uninstall Google Play Store from your device.</li>
-</ol>
- <h3>Q: What are the alternatives to Google Play Store for Redmi 9A?</h3>
- <p>A: If you don't want to use Google Play Store for Redmi 9A, you can use other app stores that offer Android apps and games. Some of the alternatives to Google Play Store for Redmi 9A are:</p>
-<ul>
-<li>Amazon Appstore: A app store that offers apps, games, and digital content for Android devices. It also features Amazon Coins, a virtual currency that can be used to buy apps and games.</li>
-<li>Aptoide: A app store that allows users to create and manage their own app stores. It also features a community of users who share and review apps and games.</li>
-<li>GetJar: A app store that offers free apps and games for Android devices. It also features rewards, coupons, and deals for users who download and use apps and games.</li>
-</ul>
- <h3>Q: How can I contact Xiaomi customer service if I have any issues with my Redmi 9A?</h3>
- <p>A: If you have any issues with your Redmi 9A, you can contact Xiaomi customer service by using one of the following methods:</p>
-<ul>
-<li>Phone: You can call Xiaomi customer service at +1 (833) 942-6648 in the US, +44 (0) 800 9160561 in the UK, +49 (0) 800 7246546 in Europe, or 1800 103 6286 in India.</li>
-<li>Email: You can email Xiaomi customer service at service.us@xiaomi.com in the US, service.uk@xiaomi.com in the UK, service.eu@xiaomi.com in Europe, or service.in@xiaomi.com in India.</li>
-<li>Website: You can visit Xiaomi customer service website at <a href="">https://www.mi.com/us/service/</a> in the US, <a href="">https://www.mi.com/uk/service/</a> in the UK, <a href="">https://www.mi.com/eu/service/</a> in Europe, or <a href="">https://www.mi.com/in/service/</a> in India.</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/tioseFevbu/cartoon-converter/scripts/Igo-primo 2.4-9.6.13 Apk.md b/spaces/tioseFevbu/cartoon-converter/scripts/Igo-primo 2.4-9.6.13 Apk.md
deleted file mode 100644
index 7a4c0ae1491cb684349f1b30795981140d6f86ad..0000000000000000000000000000000000000000
--- a/spaces/tioseFevbu/cartoon-converter/scripts/Igo-primo 2.4-9.6.13 Apk.md	
+++ /dev/null
@@ -1,66 +0,0 @@
-
-Here is a possible title and article for the keyword "igo-primo 2.4-9.6.13 apk":
-
-```
-<h1>How to Install iGO Primo 2.4-9.6.13 APK on Your Android Device</h1>
-<p>iGO Primo is one of the most popular offline navigation apps for Android devices. It offers high-quality maps, fast and accurate route calculation, 3D landmarks, POIs, voice guidance, and more. If you want to enjoy the benefits of iGO Primo on your Android device, you need to install the latest version of the app, which is 2.4-9.6.13.</p>
-<p>In this article, we will show you how to download and install iGO Primo 2.4-9.6.13 APK on your Android device in a few simple steps.</p>
-<h2>igo-primo 2.4-9.6.13 apk</h2><br /><p><b><b>Download Zip</b> &gt; <a href="https://urlcod.com/2uHxXN">https://urlcod.com/2uHxXN</a></b></p><br /><br />
-<h2>Step 1: Download iGO Primo 2.4-9.6.13 APK</h2>
-<p>The first step is to download the iGO Primo 2.4-9.6.13 APK file from a reliable source. You can use the link below to download the APK file from APKCombo.com, a trusted website that offers free and safe APK downloads.</p>
-<p><a href="https://apkcombo.com/igo-navigation/com.nng.igo.primong.igoworld/">Download iGO Primo 2.4-9.6.13 APK from APKCombo.com</a></p>
-<p>The file size is about 344 MB, so make sure you have enough storage space and a stable internet connection before downloading it.</p>
-<h2>Step 2: Enable Unknown Sources</h2>
-<p>The next step is to enable unknown sources on your Android device. This will allow you to install apps from sources other than the Google Play Store.</p>
-<p>To enable unknown sources, go to Settings > Security > Unknown Sources and toggle it on.</p>
-<p>If you have Android 8.0 or higher, you may need to grant permission for each app individually. In that case, go to Settings > Apps & Notifications > Advanced > Special App Access > Install Unknown Apps and select the app that you want to install iGO Primo from (e.g., Chrome, File Manager, etc.) and toggle on Allow from this source.</p>
-<h2>Step 3: Install iGO Primo 2.4-9.6.13 APK</h2>
-<p>The final step is to install iGO Primo 2.4-9.6.13 APK on your Android device.</p>
-<p>To do that, locate the downloaded APK file on your device using a file manager app or your browser's download manager.</p>
-<p></p>
-<p>Tap on the APK file and follow the on-screen instructions to install iGO Primo on your device.</p>
-<p>Once the installation is complete, you can launch iGO Primo from your app drawer or home screen and enjoy offline navigation on your Android device.</p>
-<h2>Conclusion</h2>
-<p>iGO Primo is a great offline navigation app for Android devices that offers many features and advantages over other apps.</p>
-<p>To install iGO Primo 2.4-9.6.13 APK on your Android device, you just need to follow three simple steps: download the APK file from a reliable source, enable unknown sources on your device, and install the APK file.</p>
-<p>We hope this article was helpful and informative for you. If you have any questions or feedback, feel free to leave a comment below.</p>
-```Here is a possible continuation of the article:
-
-```
-<h2>How to Use iGO Primo 2.4-9.6.13 APK</h2>
-<p>After installing iGO Primo 2.4-9.6.13 APK on your Android device, you may wonder how to use it effectively.</p>
-<p>In this section, we will give you some tips and tricks on how to use iGO Primo for offline navigation.</p>
-<h3>How to Download Maps for Offline Use</h3>
-<p>One of the main features of iGO Primo is that it allows you to download maps for offline use. This means you can navigate without an internet connection or roaming charges.</p>
-<p>To download maps for offline use, you need to follow these steps:</p>
-<ul>
-<li>Launch iGO Primo on your device and tap on the Menu icon on the bottom right corner.</li>
-<li>Tap on Settings and then on Map.</li>
-<li>Tap on Manage Maps and then on Download Maps.</li>
-<li>Select the regions or countries that you want to download and tap on Download.</li>
-<li>Wait for the download to finish and then tap on Done.</li>
-</ul>
-<p>You can also update your maps from the same menu by tapping on Update Maps.</p>
-<p>Note that downloading and updating maps may take some time and storage space, so make sure you have enough of both before proceeding.</p>
-<h3>How to Plan a Route with iGO Primo</h3>
-<p>Another feature of iGO Primo is that it allows you to plan a route with various options and preferences.</p>
-<p>To plan a route with iGO Primo, you need to follow these steps:</p>
-<ul>
-<li>Launch iGO Primo on your device and tap on the Search icon on the bottom left corner.</li>
-<li>Enter your destination in the search box or select it from your favorites, history, or contacts.</li>
-<li>Tap on Go and wait for iGO Primo to calculate the best route for you.</li>
-<li>You can also tap on More Options to customize your route by choosing the fastest, shortest, or most economical option, avoiding tolls, highways, ferries, or unpaved roads, or adding waypoints or alternative routes.</li>
-<li>Once you are satisfied with your route, tap on Start Navigation and follow the voice guidance and map instructions to reach your destination.</li>
-</ul>
-<h3>How to Change the Language and Voice of iGO Primo</h3>
-<p>A third feature of iGO Primo is that it allows you to change the language and voice of the app according to your preference.</p>
-<p>To change the language and voice of iGO Primo, you need to follow these steps:</p>
-<ul>
-<li>Launch iGO Primo on your device and tap on the Menu icon on the bottom right corner.</li>
-<li>Tap on Settings and then on Regional.</li>
-<li>Tap on Language and Voice and select the language and voice that you want to use from the list.</li>
-<li>You can also tap on Text-to-Speech (TTS) Pro to enable more natural and detailed voice guidance that includes street names, traffic information, and more.</li>
-<li>Tap on Done and enjoy iGO Primo in your chosen language and voice.</li>
-</ul></p> 7196e7f11a<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/tioseFevbu/cartoon-converter/scripts/Micro-cap 9 Download Full Versio.md b/spaces/tioseFevbu/cartoon-converter/scripts/Micro-cap 9 Download Full Versio.md
deleted file mode 100644
index 99412dfa0b4ba457b9fbe7a0410dccbfd79f098f..0000000000000000000000000000000000000000
--- a/spaces/tioseFevbu/cartoon-converter/scripts/Micro-cap 9 Download Full Versio.md	
+++ /dev/null
@@ -1,23 +0,0 @@
-
-<h1>How to Download and Install Micro-cap 9 Full Version for Free</h1>
-<p>Micro-cap 9 is a powerful and easy-to-use circuit simulation software that allows you to design, analyze, and optimize electronic circuits. With Micro-cap 9, you can create schematic diagrams, perform DC, AC, transient, noise, and Monte Carlo analyses, generate SPICE netlists, and export your results to various formats.</p>
-<p>If you want to download and install Micro-cap 9 full version for free, you can follow these simple steps:</p>
-<h2>Micro-cap 9 Download Full Versio</h2><br /><p><b><b>DOWNLOAD</b> &#10038; <a href="https://urlcod.com/2uHwsh">https://urlcod.com/2uHwsh</a></b></p><br /><br />
-<ol>
-<li>Go to the official website of Micro-cap 9 at <a href="https://www.spectrum-soft.com/download/download.shtm">https://www.spectrum-soft.com/download/download.shtm</a> and click on the "Download Micro-Cap 9 Evaluation" button.</li>
-<li>Fill out the registration form with your name, email address, and country. You will receive an email with a download link and a license key.</li>
-<li>Click on the download link and save the file to your computer. The file size is about 18 MB.</li>
-<li>Run the setup file and follow the installation wizard. When prompted, enter the license key that you received in your email.</li>
-<li>Launch Micro-cap 9 from your desktop or start menu. You can now enjoy the full features of Micro-cap 9 for free for 30 days.</li>
-</ol>
-<p>Note: After the 30-day trial period expires, you will need to purchase a license to continue using Micro-cap 9. You can buy a license online at <a href="https://www.spectrum-soft.com/order/order.shtm">https://www.spectrum-soft.com/order/order.shtm</a> or contact Spectrum Software at <a href="mailto:sales@spectrum-soft.com">sales@spectrum-soft.com</a>.</p>
-
-<p>Micro-cap 9 is a versatile and user-friendly software that can handle various types of circuits, from analog to digital, from linear to nonlinear, from simple to complex. You can use Micro-cap 9 to design circuits for applications such as audio, power, RF, control, signal processing, and more.</p>
-<p>Micro-cap 9 has a rich library of components that you can use to build your circuits. You can also create your own custom components and models using the built-in editor. Micro-cap 9 supports SPICE 3f5 syntax and compatibility, so you can import and export SPICE netlists and models from other sources.</p>
-<p>Micro-cap 9 also has a graphical user interface that makes it easy to create and edit schematic diagrams. You can use the drag-and-drop feature, the toolbar buttons, the keyboard shortcuts, or the menu commands to manipulate the components and wires. You can also use the zoom, pan, grid, snap, and alignment tools to adjust the layout of your schematic.</p>
-
-<p>Once you have created your schematic diagram, you can perform various types of analyses using Micro-cap 9. You can choose from DC, AC, transient, noise, Fourier, temperature, worst case, Monte Carlo, and parametric analyses. You can also use the interactive mode to change the values of components and sources and see the effects on the circuit in real time.</p>
-<p>Micro-cap 9 provides you with various ways to display and analyze your simulation results. You can use the plot window to view the waveforms of voltages, currents, powers, and other variables. You can also use the data window to view the numerical values of the simulation results in a table format. You can customize the appearance and settings of the plot and data windows to suit your preferences.</p>
-<p>Micro-cap 9 also allows you to export your simulation results to various formats. You can save your plots as bitmap, metafile, or JPEG files. You can also copy your plots to the clipboard and paste them into other applications. You can save your data as ASCII, CSV, or binary files. You can also export your data to Excel or MATLAB for further processing.</p> 7b8c122e87<br />
-<br />
-<br />
\ No newline at end of file
diff --git a/spaces/tomofi/MMOCR/mmocr/models/textrecog/recognizer/seg_recognizer.py b/spaces/tomofi/MMOCR/mmocr/models/textrecog/recognizer/seg_recognizer.py
deleted file mode 100644
index 1746dbf98d38c47e077adfe52a7ed44a9b813f46..0000000000000000000000000000000000000000
--- a/spaces/tomofi/MMOCR/mmocr/models/textrecog/recognizer/seg_recognizer.py
+++ /dev/null
@@ -1,150 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import warnings
-
-from mmocr.models.builder import (RECOGNIZERS, build_backbone, build_convertor,
-                                  build_head, build_loss, build_neck,
-                                  build_preprocessor)
-from .base import BaseRecognizer
-
-
-@RECOGNIZERS.register_module()
-class SegRecognizer(BaseRecognizer):
-    """Base class for segmentation based recognizer."""
-
-    def __init__(self,
-                 preprocessor=None,
-                 backbone=None,
-                 neck=None,
-                 head=None,
-                 loss=None,
-                 label_convertor=None,
-                 train_cfg=None,
-                 test_cfg=None,
-                 pretrained=None,
-                 init_cfg=None):
-        super().__init__(init_cfg=init_cfg)
-
-        # Label_convertor
-        assert label_convertor is not None
-        self.label_convertor = build_convertor(label_convertor)
-
-        # Preprocessor module, e.g., TPS
-        self.preprocessor = None
-        if preprocessor is not None:
-            self.preprocessor = build_preprocessor(preprocessor)
-
-        # Backbone
-        assert backbone is not None
-        self.backbone = build_backbone(backbone)
-
-        # Neck
-        assert neck is not None
-        self.neck = build_neck(neck)
-
-        # Head
-        assert head is not None
-        head.update(num_classes=self.label_convertor.num_classes())
-        self.head = build_head(head)
-
-        # Loss
-        assert loss is not None
-        self.loss = build_loss(loss)
-
-        self.train_cfg = train_cfg
-        self.test_cfg = test_cfg
-        if pretrained is not None:
-            warnings.warn('DeprecationWarning: pretrained is a deprecated \
-                key, please consider using init_cfg')
-            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
-
-    def extract_feat(self, img):
-        """Directly extract features from the backbone."""
-        if self.preprocessor is not None:
-            img = self.preprocessor(img)
-
-        x = self.backbone(img)
-
-        return x
-
-    def forward_train(self, img, img_metas, gt_kernels=None):
-        """
-        Args:
-            img (tensor): Input images of shape (N, C, H, W).
-                Typically these should be mean centered and std scaled.
-            img_metas (list[dict]): A list of image info dict where each dict
-                contains: 'img_shape', 'filename', and may also contain
-                'ori_shape', and 'img_norm_cfg'.
-                For details on the values of these keys see
-                :class:`mmdet.datasets.pipelines.Collect`.
-
-        Returns:
-            dict[str, tensor]: A dictionary of loss components.
-        """
-
-        feats = self.extract_feat(img)
-
-        out_neck = self.neck(feats)
-
-        out_head = self.head(out_neck)
-
-        loss_inputs = (out_neck, out_head, gt_kernels)
-
-        losses = self.loss(*loss_inputs)
-
-        return losses
-
-    def simple_test(self, img, img_metas, **kwargs):
-        """Test function without test time augmentation.
-
-        Args:
-            imgs (torch.Tensor): Image input tensor.
-            img_metas (list[dict]): List of image information.
-
-        Returns:
-            list[str]: Text label result of each image.
-        """
-
-        feat = self.extract_feat(img)
-
-        out_neck = self.neck(feat)
-
-        out_head = self.head(out_neck)
-
-        for img_meta in img_metas:
-            valid_ratio = 1.0 * img_meta['resize_shape'][1] / img.size(-1)
-            img_meta['valid_ratio'] = valid_ratio
-
-        texts, scores = self.label_convertor.tensor2str(out_head, img_metas)
-
-        # flatten batch results
-        results = []
-        for text, score in zip(texts, scores):
-            results.append(dict(text=text, score=score))
-
-        return results
-
-    def merge_aug_results(self, aug_results):
-        out_text, out_score = '', -1
-        for result in aug_results:
-            text = result[0]['text']
-            score = sum(result[0]['score']) / max(1, len(text))
-            if score > out_score:
-                out_text = text
-                out_score = score
-        out_results = [dict(text=out_text, score=out_score)]
-        return out_results
-
-    def aug_test(self, imgs, img_metas, **kwargs):
-        """Test function with test time augmentation.
-
-        Args:
-            imgs (list[tensor]): Tensor should have shape NxCxHxW,
-                which contains all images in the batch.
-            img_metas (list[list[dict]]): The metadata of images.
-        """
-        aug_results = []
-        for img, img_meta in zip(imgs, img_metas):
-            result = self.simple_test(img, img_meta, **kwargs)
-            aug_results.append(result)
-
-        return self.merge_aug_results(aug_results)
diff --git a/spaces/tomofi/MMOCR/tools/data/textrecog/totaltext_converter.py b/spaces/tomofi/MMOCR/tools/data/textrecog/totaltext_converter.py
deleted file mode 100644
index 38b5b9f4fc4f2b99c83f493dadd17d6ae7e3e01a..0000000000000000000000000000000000000000
--- a/spaces/tomofi/MMOCR/tools/data/textrecog/totaltext_converter.py
+++ /dev/null
@@ -1,386 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import argparse
-import glob
-import os
-import os.path as osp
-import re
-
-import mmcv
-import numpy as np
-import scipy.io as scio
-import yaml
-from shapely.geometry import Polygon
-
-from mmocr.datasets.pipelines.crop import crop_img
-from mmocr.utils.fileio import list_to_file
-
-
-def collect_files(img_dir, gt_dir, split):
-    """Collect all images and their corresponding groundtruth files.
-
-    Args:
-        img_dir(str): The image directory
-        gt_dir(str): The groundtruth directory
-        split(str): The split of dataset. Namely: training or test
-    Returns:
-        files(list): The list of tuples (img_file, groundtruth_file)
-    """
-    assert isinstance(img_dir, str)
-    assert img_dir
-    assert isinstance(gt_dir, str)
-    assert gt_dir
-
-    # note that we handle png and jpg only. Pls convert others such as gif to
-    # jpg or png offline
-    suffixes = ['.png', '.PNG', '.jpg', '.JPG', '.jpeg', '.JPEG']
-    # suffixes = ['.png']
-
-    imgs_list = []
-    for suffix in suffixes:
-        imgs_list.extend(glob.glob(osp.join(img_dir, '*' + suffix)))
-
-    imgs_list = sorted(imgs_list)
-    ann_list = sorted(
-        [osp.join(gt_dir, gt_file) for gt_file in os.listdir(gt_dir)])
-
-    files = [(img_file, gt_file)
-             for (img_file, gt_file) in zip(imgs_list, ann_list)]
-    assert len(files), f'No images found in {img_dir}'
-    print(f'Loaded {len(files)} images from {img_dir}')
-
-    return files
-
-
-def collect_annotations(files, nproc=1):
-    """Collect the annotation information.
-
-    Args:
-        files(list): The list of tuples (image_file, groundtruth_file)
-        nproc(int): The number of process to collect annotations
-    Returns:
-        images(list): The list of image information dicts
-    """
-    assert isinstance(files, list)
-    assert isinstance(nproc, int)
-
-    if nproc > 1:
-        images = mmcv.track_parallel_progress(
-            load_img_info, files, nproc=nproc)
-    else:
-        images = mmcv.track_progress(load_img_info, files)
-
-    return images
-
-
-def get_contours_mat(gt_path):
-    """Get the contours and words for each ground_truth mat file.
-
-    Args:
-        gt_path(str): The relative path of the ground_truth mat file
-    Returns:
-        contours(list[lists]): A list of lists of contours
-        for the text instances
-        words(list[list]): A list of lists of words (string)
-        for the text instances
-    """
-    assert isinstance(gt_path, str)
-
-    contours = []
-    words = []
-    data = scio.loadmat(gt_path)
-    data_polygt = data['polygt']
-
-    for i, lines in enumerate(data_polygt):
-        X = np.array(lines[1])
-        Y = np.array(lines[3])
-
-        point_num = len(X[0])
-        word = lines[4]
-        if len(word) == 0:
-            word = '???'
-        else:
-            word = word[0]
-
-        if word == '#':
-            word = '###'
-            continue
-
-        words.append(word)
-
-        arr = np.concatenate([X, Y]).T
-        contour = []
-        for i in range(point_num):
-            contour.append(arr[i][0])
-            contour.append(arr[i][1])
-        contours.append(np.asarray(contour))
-
-    return contours, words
-
-
-def load_mat_info(img_info, gt_file):
-    """Load the information of one ground truth in .mat format.
-
-    Args:
-        img_info(dict): The dict of only the image information
-        gt_file(str): The relative path of the ground_truth mat
-        file for one image
-    Returns:
-        img_info(dict): The dict of the img and annotation information
-    """
-    assert isinstance(img_info, dict)
-    assert isinstance(gt_file, str)
-
-    contours, words = get_contours_mat(gt_file)
-    anno_info = []
-    for contour, word in zip(contours, words):
-        if contour.shape[0] == 2:
-            continue
-        coordinates = np.array(contour).reshape(-1, 2)
-        polygon = Polygon(coordinates)
-
-        # convert to COCO style XYWH format
-        min_x, min_y, max_x, max_y = polygon.bounds
-        bbox = [min_x, min_y, max_x, min_y, max_x, max_y, min_x, max_y]
-        anno = dict(word=word, bbox=bbox)
-        anno_info.append(anno)
-
-    img_info.update(anno_info=anno_info)
-    return img_info
-
-
-def process_line(line, contours, words):
-    """Get the contours and words by processing each line in the gt file.
-
-    Args:
-        line(str): The line in gt file containing annotation info
-        contours(list[lists]): A list of lists of contours
-        for the text instances
-        words(list[list]): A list of lists of words (string)
-        for the text instances
-    Returns:
-        contours(list[lists]): A list of lists of contours
-        for the text instances
-        words(list[list]): A list of lists of words (string)
-        for the text instances
-    """
-
-    line = '{' + line.replace('[[', '[').replace(']]', ']') + '}'
-    ann_dict = re.sub('([0-9]) +([0-9])', r'\1,\2', line)
-    ann_dict = re.sub('([0-9]) +([ 0-9])', r'\1,\2', ann_dict)
-    ann_dict = re.sub('([0-9]) -([0-9])', r'\1,-\2', ann_dict)
-    ann_dict = ann_dict.replace("[u',']", "[u'#']")
-    ann_dict = yaml.safe_load(ann_dict)
-
-    X = np.array([ann_dict['x']])
-    Y = np.array([ann_dict['y']])
-
-    if len(ann_dict['transcriptions']) == 0:
-        word = '???'
-    else:
-        word = ann_dict['transcriptions'][0]
-        if len(ann_dict['transcriptions']) > 1:
-            for ann_word in ann_dict['transcriptions'][1:]:
-                word += ',' + ann_word
-        word = str(eval(word))
-    words.append(word)
-
-    point_num = len(X[0])
-
-    arr = np.concatenate([X, Y]).T
-    contour = []
-    for i in range(point_num):
-        contour.append(arr[i][0])
-        contour.append(arr[i][1])
-    contours.append(np.asarray(contour))
-
-    return contours, words
-
-
-def get_contours_txt(gt_path):
-    """Get the contours and words for each ground_truth txt file.
-
-    Args:
-        gt_path(str): The relative path of the ground_truth mat file
-    Returns:
-        contours(list[lists]): A list of lists of contours
-        for the text instances
-        words(list[list]): A list of lists of words (string)
-        for the text instances
-    """
-    assert isinstance(gt_path, str)
-
-    contours = []
-    words = []
-
-    with open(gt_path, 'r') as f:
-        tmp_line = ''
-        for idx, line in enumerate(f):
-            line = line.strip()
-            if idx == 0:
-                tmp_line = line
-                continue
-            if not line.startswith('x:'):
-                tmp_line += ' ' + line
-                continue
-            else:
-                complete_line = tmp_line
-                tmp_line = line
-            contours, words = process_line(complete_line, contours, words)
-
-        if tmp_line != '':
-            contours, words = process_line(tmp_line, contours, words)
-
-        for word in words:
-
-            if word == '#':
-                word = '###'
-                continue
-
-    return contours, words
-
-
-def load_txt_info(gt_file, img_info):
-    """Load the information of one ground truth in .txt format.
-
-    Args:
-        img_info(dict): The dict of only the image information
-        gt_file(str): The relative path of the ground_truth mat
-        file for one image
-    Returns:
-        img_info(dict): The dict of the img and annotation information
-    """
-
-    contours, words = get_contours_txt(gt_file)
-    anno_info = []
-    for contour, word in zip(contours, words):
-        if contour.shape[0] == 2:
-            continue
-        coordinates = np.array(contour).reshape(-1, 2)
-        polygon = Polygon(coordinates)
-
-        # convert to COCO style XYWH format
-        min_x, min_y, max_x, max_y = polygon.bounds
-        bbox = [min_x, min_y, max_x, min_y, max_x, max_y, min_x, max_y]
-        anno = dict(word=word, bbox=bbox)
-        anno_info.append(anno)
-
-    img_info.update(anno_info=anno_info)
-    return img_info
-
-
-def generate_ann(root_path, split, image_infos):
-    """Generate cropped annotations and label txt file.
-
-    Args:
-        root_path(str): The relative path of the totaltext file
-        split(str): The split of dataset. Namely: training or test
-        image_infos(list[dict]): A list of dicts of the img and
-        annotation information
-    """
-
-    dst_image_root = osp.join(root_path, 'dst_imgs', split)
-    if split == 'training':
-        dst_label_file = osp.join(root_path, 'train_label.txt')
-    elif split == 'test':
-        dst_label_file = osp.join(root_path, 'test_label.txt')
-    os.makedirs(dst_image_root, exist_ok=True)
-
-    lines = []
-    for image_info in image_infos:
-        index = 1
-        src_img_path = osp.join(root_path, 'imgs', image_info['file_name'])
-        image = mmcv.imread(src_img_path)
-        src_img_root = osp.splitext(image_info['file_name'])[0].split('/')[1]
-
-        for anno in image_info['anno_info']:
-            word = anno['word']
-            dst_img = crop_img(image, anno['bbox'])
-
-            # Skip invalid annotations
-            if min(dst_img.shape) == 0:
-                continue
-
-            dst_img_name = f'{src_img_root}_{index}.png'
-            index += 1
-            dst_img_path = osp.join(dst_image_root, dst_img_name)
-            mmcv.imwrite(dst_img, dst_img_path)
-            lines.append(f'{osp.basename(dst_image_root)}/{dst_img_name} '
-                         f'{word}')
-    list_to_file(dst_label_file, lines)
-
-
-def load_img_info(files):
-    """Load the information of one image.
-
-    Args:
-        files(tuple): The tuple of (img_file, groundtruth_file)
-    Returns:
-        img_info(dict): The dict of the img and annotation information
-    """
-    assert isinstance(files, tuple)
-
-    img_file, gt_file = files
-    # read imgs with ignoring orientations
-    img = mmcv.imread(img_file, 'unchanged')
-
-    split_name = osp.basename(osp.dirname(img_file))
-    img_info = dict(
-        # remove img_prefix for filename
-        file_name=osp.join(split_name, osp.basename(img_file)),
-        height=img.shape[0],
-        width=img.shape[1],
-        # anno_info=anno_info,
-        segm_file=osp.join(split_name, osp.basename(gt_file)))
-
-    if osp.splitext(gt_file)[1] == '.mat':
-        img_info = load_mat_info(img_info, gt_file)
-    elif osp.splitext(gt_file)[1] == '.txt':
-        img_info = load_txt_info(gt_file, img_info)
-    else:
-        raise NotImplementedError
-
-    return img_info
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description='Convert totaltext annotations to COCO format')
-    parser.add_argument('root_path', help='totaltext root path')
-    parser.add_argument('-o', '--out-dir', help='output path')
-    parser.add_argument(
-        '--split-list',
-        nargs='+',
-        help='a list of splits. e.g., "--split_list training test"')
-
-    parser.add_argument(
-        '--nproc', default=1, type=int, help='number of process')
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    root_path = args.root_path
-    out_dir = args.out_dir if args.out_dir else root_path
-    mmcv.mkdir_or_exist(out_dir)
-
-    img_dir = osp.join(root_path, 'imgs')
-    gt_dir = osp.join(root_path, 'annotations')
-
-    set_name = {}
-    for split in args.split_list:
-        set_name.update({split: 'instances_' + split + '.json'})
-        assert osp.exists(osp.join(img_dir, split))
-
-    for split, json_name in set_name.items():
-        print(f'Converting {split} into {json_name}')
-        with mmcv.Timer(
-                print_tmpl='It takes {}s to convert totaltext annotation'):
-            files = collect_files(
-                osp.join(img_dir, split), osp.join(gt_dir, split), split)
-            image_infos = collect_annotations(files, nproc=args.nproc)
-            generate_ann(root_path, split, image_infos)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/spaces/tomofi/NDLOCR/src/ndl_layout/mmdetection/configs/ld/ld_r50_gflv1_r101_fpn_coco_1x.py b/spaces/tomofi/NDLOCR/src/ndl_layout/mmdetection/configs/ld/ld_r50_gflv1_r101_fpn_coco_1x.py
deleted file mode 100644
index 923c626363c2f49e8ad15616a09b6cb52260923a..0000000000000000000000000000000000000000
--- a/spaces/tomofi/NDLOCR/src/ndl_layout/mmdetection/configs/ld/ld_r50_gflv1_r101_fpn_coco_1x.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = ['./ld_r18_gflv1_r101_fpn_coco_1x.py']
-model = dict(
-    pretrained='torchvision://resnet50',
-    backbone=dict(
-        type='ResNet',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=1,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        norm_eval=True,
-        style='pytorch'),
-    neck=dict(
-        type='FPN',
-        in_channels=[256, 512, 1024, 2048],
-        out_channels=256,
-        start_level=1,
-        add_extra_convs='on_output',
-        num_outs=5))
diff --git a/spaces/tomofi/NDLOCR/src/ndl_layout/mmdetection/configs/pascal_voc/faster_rcnn_r50_fpn_1x_voc0712.py b/spaces/tomofi/NDLOCR/src/ndl_layout/mmdetection/configs/pascal_voc/faster_rcnn_r50_fpn_1x_voc0712.py
deleted file mode 100644
index 7866acebea689e7a863a836c326b1407de733fe8..0000000000000000000000000000000000000000
--- a/spaces/tomofi/NDLOCR/src/ndl_layout/mmdetection/configs/pascal_voc/faster_rcnn_r50_fpn_1x_voc0712.py
+++ /dev/null
@@ -1,14 +0,0 @@
-_base_ = [
-    '../_base_/models/faster_rcnn_r50_fpn.py', '../_base_/datasets/voc0712.py',
-    '../_base_/default_runtime.py'
-]
-model = dict(roi_head=dict(bbox_head=dict(num_classes=20)))
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
-optimizer_config = dict(grad_clip=None)
-# learning policy
-# actual epoch = 3 * 3 = 9
-lr_config = dict(policy='step', step=[3])
-# runtime settings
-runner = dict(
-    type='EpochBasedRunner', max_epochs=4)  # actual epoch = 4 * 3 = 12
diff --git a/spaces/trttung1610/musicgen/tests/modules/test_conv.py b/spaces/trttung1610/musicgen/tests/modules/test_conv.py
deleted file mode 100644
index 28fbc4f1a0ebaf41b56947b767958ae696e75eec..0000000000000000000000000000000000000000
--- a/spaces/trttung1610/musicgen/tests/modules/test_conv.py
+++ /dev/null
@@ -1,203 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from itertools import product
-import math
-import random
-
-import pytest
-import torch
-from torch import nn
-
-from audiocraft.modules import (
-    NormConv1d,
-    NormConvTranspose1d,
-    StreamableConv1d,
-    StreamableConvTranspose1d,
-    pad1d,
-    unpad1d,
-)
-
-
-def test_get_extra_padding_for_conv1d():
-    # TODO: Implement me!
-    pass
-
-
-def test_pad1d_zeros():
-    x = torch.randn(1, 1, 20)
-
-    xp1 = pad1d(x, (0, 5), mode='constant', value=0.)
-    assert xp1.shape[-1] == 25
-    xp2 = pad1d(x, (5, 5), mode='constant', value=0.)
-    assert xp2.shape[-1] == 30
-    xp3 = pad1d(x, (0, 0), mode='constant', value=0.)
-    assert xp3.shape[-1] == 20
-    xp4 = pad1d(x, (10, 30), mode='constant', value=0.)
-    assert xp4.shape[-1] == 60
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (-1, 0), mode='constant', value=0.)
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (0, -1), mode='constant', value=0.)
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (-1, -1), mode='constant', value=0.)
-
-
-def test_pad1d_reflect():
-    x = torch.randn(1, 1, 20)
-
-    xp1 = pad1d(x, (0, 5), mode='reflect', value=0.)
-    assert xp1.shape[-1] == 25
-    xp2 = pad1d(x, (5, 5), mode='reflect', value=0.)
-    assert xp2.shape[-1] == 30
-    xp3 = pad1d(x, (0, 0), mode='reflect', value=0.)
-    assert xp3.shape[-1] == 20
-    xp4 = pad1d(x, (10, 30), mode='reflect', value=0.)
-    assert xp4.shape[-1] == 60
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (-1, 0), mode='reflect', value=0.)
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (0, -1), mode='reflect', value=0.)
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (-1, -1), mode='reflect', value=0.)
-
-
-def test_unpad1d():
-    x = torch.randn(1, 1, 20)
-
-    u1 = unpad1d(x, (5, 5))
-    assert u1.shape[-1] == 10
-    u2 = unpad1d(x, (0, 5))
-    assert u2.shape[-1] == 15
-    u3 = unpad1d(x, (5, 0))
-    assert u3.shape[-1] == 15
-    u4 = unpad1d(x, (0, 0))
-    assert u4.shape[-1] == x.shape[-1]
-
-    with pytest.raises(AssertionError):
-        unpad1d(x, (-1, 0))
-
-    with pytest.raises(AssertionError):
-        unpad1d(x, (0, -1))
-
-    with pytest.raises(AssertionError):
-        unpad1d(x, (-1, -1))
-
-
-class TestNormConv1d:
-
-    def test_norm_conv1d_modules(self):
-        N, C, T = 2, 2, random.randrange(1, 100_000)
-        t0 = torch.randn(N, C, T)
-
-        C_out, kernel_size, stride = 1, 4, 1
-        expected_out_length = int((T - kernel_size) / stride + 1)
-        wn_conv = NormConv1d(C, 1, kernel_size=4, norm='weight_norm')
-        gn_conv = NormConv1d(C, 1, kernel_size=4, norm='time_group_norm')
-        nn_conv = NormConv1d(C, 1, kernel_size=4, norm='none')
-
-        assert isinstance(wn_conv.norm, nn.Identity)
-        assert isinstance(wn_conv.conv, nn.Conv1d)
-
-        assert isinstance(gn_conv.norm, nn.GroupNorm)
-        assert isinstance(gn_conv.conv, nn.Conv1d)
-
-        assert isinstance(nn_conv.norm, nn.Identity)
-        assert isinstance(nn_conv.conv, nn.Conv1d)
-
-        for conv_layer in [wn_conv, gn_conv, nn_conv]:
-            out = conv_layer(t0)
-            assert isinstance(out, torch.Tensor)
-            assert list(out.shape) == [N, C_out, expected_out_length]
-
-
-class TestNormConvTranspose1d:
-
-    def test_normalizations(self):
-        N, C, T = 2, 2, random.randrange(1, 100_000)
-        t0 = torch.randn(N, C, T)
-
-        C_out, kernel_size, stride = 1, 4, 1
-        expected_out_length = (T - 1) * stride + (kernel_size - 1) + 1
-
-        wn_convtr = NormConvTranspose1d(C, C_out, kernel_size=kernel_size, stride=stride, norm='weight_norm')
-        gn_convtr = NormConvTranspose1d(C, C_out, kernel_size=kernel_size, stride=stride, norm='time_group_norm')
-        nn_convtr = NormConvTranspose1d(C, C_out, kernel_size=kernel_size, stride=stride, norm='none')
-
-        assert isinstance(wn_convtr.norm, nn.Identity)
-        assert isinstance(wn_convtr.convtr, nn.ConvTranspose1d)
-
-        assert isinstance(gn_convtr.norm, nn.GroupNorm)
-        assert isinstance(gn_convtr.convtr, nn.ConvTranspose1d)
-
-        assert isinstance(nn_convtr.norm, nn.Identity)
-        assert isinstance(nn_convtr.convtr, nn.ConvTranspose1d)
-
-        for convtr_layer in [wn_convtr, gn_convtr, nn_convtr]:
-            out = convtr_layer(t0)
-            assert isinstance(out, torch.Tensor)
-            assert list(out.shape) == [N, C_out, expected_out_length]
-
-
-class TestStreamableConv1d:
-
-    def get_streamable_conv1d_output_length(self, length, kernel_size, stride, dilation):
-        # StreamableConv1d internally pads to make sure that the last window is full
-        padding_total = (kernel_size - 1) * dilation - (stride - 1)
-        n_frames = (length - kernel_size + padding_total) / stride + 1
-        ideal_length = (math.ceil(n_frames) - 1) * stride + (kernel_size - padding_total)
-        return ideal_length // stride
-
-    def test_streamable_conv1d(self):
-        N, C, T = 2, 2, random.randrange(1, 100_000)
-        t0 = torch.randn(N, C, T)
-        C_out = 1
-
-        # conv params are [(kernel_size, stride, dilation)]
-        conv_params = [(4, 1, 1), (4, 2, 1), (3, 1, 3), (10, 5, 1), (3, 2, 3)]
-        for causal, (kernel_size, stride, dilation) in product([False, True], conv_params):
-            expected_out_length = self.get_streamable_conv1d_output_length(T, kernel_size, stride, dilation)
-            sconv = StreamableConv1d(C, C_out, kernel_size=kernel_size, stride=stride, dilation=dilation, causal=causal)
-            out = sconv(t0)
-            assert isinstance(out, torch.Tensor)
-            print(list(out.shape), [N, C_out, expected_out_length])
-            assert list(out.shape) == [N, C_out, expected_out_length]
-
-
-class TestStreamableConvTranspose1d:
-
-    def get_streamable_convtr1d_output_length(self, length, kernel_size, stride):
-        padding_total = (kernel_size - stride)
-        return (length - 1) * stride - padding_total + (kernel_size - 1) + 1
-
-    def test_streamable_convtr1d(self):
-        N, C, T = 2, 2, random.randrange(1, 100_000)
-        t0 = torch.randn(N, C, T)
-
-        C_out = 1
-
-        with pytest.raises(AssertionError):
-            StreamableConvTranspose1d(C, C_out, kernel_size=4, causal=False, trim_right_ratio=0.5)
-            StreamableConvTranspose1d(C, C_out, kernel_size=4, causal=True, trim_right_ratio=-1.)
-            StreamableConvTranspose1d(C, C_out, kernel_size=4, causal=True, trim_right_ratio=2)
-
-        # causal params are [(causal, trim_right)]
-        causal_params = [(False, 1.0), (True, 1.0), (True, 0.5), (True, 0.0)]
-        # conv params are [(kernel_size, stride)]
-        conv_params = [(4, 1), (4, 2), (3, 1), (10, 5)]
-        for ((causal, trim_right_ratio), (kernel_size, stride)) in product(causal_params, conv_params):
-            expected_out_length = self.get_streamable_convtr1d_output_length(T, kernel_size, stride)
-            sconvtr = StreamableConvTranspose1d(C, C_out, kernel_size=kernel_size, stride=stride,
-                                                causal=causal, trim_right_ratio=trim_right_ratio)
-            out = sconvtr(t0)
-            assert isinstance(out, torch.Tensor)
-            assert list(out.shape) == [N, C_out, expected_out_length]
diff --git a/spaces/ucalyptus/PTI/scripts/latent_editor_wrapper.py b/spaces/ucalyptus/PTI/scripts/latent_editor_wrapper.py
deleted file mode 100644
index 8f3297b5574e495376a2c1686466780dee953a7d..0000000000000000000000000000000000000000
--- a/spaces/ucalyptus/PTI/scripts/latent_editor_wrapper.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import torch
-from configs import paths_config
-from editings.latent_editor import LatentEditor
-
-
-class LatentEditorWrapper:
-
-    def __init__(self):
-
-        self.interfacegan_directions = {'age': f'{paths_config.interfacegan_age}',
-                                        'smile': f'{paths_config.interfacegan_smile}',
-                                        'rotation': f'{paths_config.interfacegan_rotation}'}
-        self.interfacegan_directions_tensors = {name: torch.load(path).cuda() for name, path in
-                                                self.interfacegan_directions.items()}
-        self.ganspace_pca = torch.load(f'{paths_config.ffhq_pca}')
-
-        ## For more edit directions please visit ..
-        self.ganspace_directions = {
-            'eye_openness': (54, 7, 8, 5),
-            'smile': (46, 4, 5, -6),
-            'trimmed_beard': (58, 7, 9, 7),
-        }
-
-        self.latent_editor = LatentEditor()
-
-    def get_single_ganspace_edits(self, start_w, factors):
-        latents_to_display = []
-        for ganspace_direction in self.ganspace_directions.values():
-            for factor in factors:
-                edit_direction = list(ganspace_direction)
-                edit_direction[-1] = factor
-                edit_direction = tuple(edit_direction)
-                new_w = self.latent_editor.apply_ganspace(start_w, self.ganspace_pca, [edit_direction])
-                latents_to_display.append(new_w)
-        return latents_to_display
-
-    def get_single_interface_gan_edits(self, start_w, factors):
-        latents_to_display = {}
-        for direction in ['rotation', 'smile', 'age']:
-            for factor in factors:
-                if direction not in latents_to_display:
-                    latents_to_display[direction] = {}
-                latents_to_display[direction][factor] = self.latent_editor.apply_interfacegan(
-                    start_w, self.interfacegan_directions_tensors[direction], factor / 2)
-
-        return latents_to_display
diff --git a/spaces/umichVision/virtex-redcaps/virtex/__init__.py b/spaces/umichVision/virtex-redcaps/virtex/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/usbethFlerru/sovits-modelsV2/example/Awesome Miner 4.3.1 Ultimate Plus Update MinerKG.md b/spaces/usbethFlerru/sovits-modelsV2/example/Awesome Miner 4.3.1 Ultimate Plus Update MinerKG.md
deleted file mode 100644
index a5bd807f533c5c03bf85c6833beada45493626cb..0000000000000000000000000000000000000000
--- a/spaces/usbethFlerru/sovits-modelsV2/example/Awesome Miner 4.3.1 Ultimate Plus Update MinerKG.md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>Awesome Miner 4.3.1 Ultimate Plus Update MinerKG</h2><br /><p><b><b>DOWNLOAD</b> &#10026; <a href="https://urlcod.com/2uyWQe">https://urlcod.com/2uyWQe</a></b></p><br /><br />
-
- aaccfb2cb3<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/usbethFlerru/sovits-modelsV2/example/Ciel Ciel Gestion Commerciale Evolution 2013 Avec Crack Extra Quality.md b/spaces/usbethFlerru/sovits-modelsV2/example/Ciel Ciel Gestion Commerciale Evolution 2013 Avec Crack Extra Quality.md
deleted file mode 100644
index cf46f1fa6b56709cb206315f64c52185a0a9b889..0000000000000000000000000000000000000000
--- a/spaces/usbethFlerru/sovits-modelsV2/example/Ciel Ciel Gestion Commerciale Evolution 2013 Avec Crack Extra Quality.md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>Ciel Ciel Gestion Commerciale Evolution 2013 avec crack</h2><br /><p><b><b>Download File</b> &#9999; <a href="https://urlcod.com/2uyXih">https://urlcod.com/2uyXih</a></b></p><br /><br />
-<br />
-Crack Ciel Gestion Commerciale Evolution 2013 Hit DOWNLOAD 09d271e77f Ciel Solution 2010 + Crack. . et le suivi complet de votre activit . 4d29de3e1b<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/usbethFlerru/sovits-modelsV2/example/Crysis 3 Fixer 1.0.3 Free 14.md b/spaces/usbethFlerru/sovits-modelsV2/example/Crysis 3 Fixer 1.0.3 Free 14.md
deleted file mode 100644
index 7f2df6d302018b77d8b17dcfcbeebd3b774b3cf5..0000000000000000000000000000000000000000
--- a/spaces/usbethFlerru/sovits-modelsV2/example/Crysis 3 Fixer 1.0.3 Free 14.md	
+++ /dev/null
@@ -1,6 +0,0 @@
-<h2>crysis 3 fixer 1.0.3 free 14</h2><br /><p><b><b>DOWNLOAD</b> ->>->>->> <a href="https://urlcod.com/2uyXkK">https://urlcod.com/2uyXkK</a></b></p><br /><br />
-
-A patch for Crysis 3 had just came out and it has significantly helped my performance. 0 0. 4d29de3e1b<br />
-<br />
-<br />
-<p></p>
diff --git a/spaces/user238921933/stable-diffusion-webui/html/extra-networks-no-cards.html b/spaces/user238921933/stable-diffusion-webui/html/extra-networks-no-cards.html
deleted file mode 100644
index 389358d6c4b383fdc3c5686e029e7b3b1ae9a493..0000000000000000000000000000000000000000
--- a/spaces/user238921933/stable-diffusion-webui/html/extra-networks-no-cards.html
+++ /dev/null
@@ -1,8 +0,0 @@
-<div class='nocards'>
-<h1>Nothing here. Add some content to the following directories:</h1>
-
-<ul>
-{dirs}
-</ul>
-</div>
-
diff --git a/spaces/user238921933/stable-diffusion-webui/modules/sd_hijack_unet.py b/spaces/user238921933/stable-diffusion-webui/modules/sd_hijack_unet.py
deleted file mode 100644
index ac931c80df9b7c34b342d560bc969ff461b0afc7..0000000000000000000000000000000000000000
--- a/spaces/user238921933/stable-diffusion-webui/modules/sd_hijack_unet.py
+++ /dev/null
@@ -1,79 +0,0 @@
-import torch
-from packaging import version
-
-from modules import devices
-from modules.sd_hijack_utils import CondFunc
-
-
-class TorchHijackForUnet:
-    """
-    This is torch, but with cat that resizes tensors to appropriate dimensions if they do not match;
-    this makes it possible to create pictures with dimensions that are multiples of 8 rather than 64
-    """
-
-    def __getattr__(self, item):
-        if item == 'cat':
-            return self.cat
-
-        if hasattr(torch, item):
-            return getattr(torch, item)
-
-        raise AttributeError("'{}' object has no attribute '{}'".format(type(self).__name__, item))
-
-    def cat(self, tensors, *args, **kwargs):
-        if len(tensors) == 2:
-            a, b = tensors
-            if a.shape[-2:] != b.shape[-2:]:
-                a = torch.nn.functional.interpolate(a, b.shape[-2:], mode="nearest")
-
-            tensors = (a, b)
-
-        return torch.cat(tensors, *args, **kwargs)
-
-
-th = TorchHijackForUnet()
-
-
-# Below are monkey patches to enable upcasting a float16 UNet for float32 sampling
-def apply_model(orig_func, self, x_noisy, t, cond, **kwargs):
-
-    if isinstance(cond, dict):
-        for y in cond.keys():
-            cond[y] = [x.to(devices.dtype_unet) if isinstance(x, torch.Tensor) else x for x in cond[y]]
-
-    with devices.autocast():
-        return orig_func(self, x_noisy.to(devices.dtype_unet), t.to(devices.dtype_unet), cond, **kwargs).float()
-
-
-class GELUHijack(torch.nn.GELU, torch.nn.Module):
-    def __init__(self, *args, **kwargs):
-        torch.nn.GELU.__init__(self, *args, **kwargs)
-    def forward(self, x):
-        if devices.unet_needs_upcast:
-            return torch.nn.GELU.forward(self.float(), x.float()).to(devices.dtype_unet)
-        else:
-            return torch.nn.GELU.forward(self, x)
-
-
-ddpm_edit_hijack = None
-def hijack_ddpm_edit():
-    global ddpm_edit_hijack
-    if not ddpm_edit_hijack:
-        CondFunc('modules.models.diffusion.ddpm_edit.LatentDiffusion.decode_first_stage', first_stage_sub, first_stage_cond)
-        CondFunc('modules.models.diffusion.ddpm_edit.LatentDiffusion.encode_first_stage', first_stage_sub, first_stage_cond)
-        ddpm_edit_hijack = CondFunc('modules.models.diffusion.ddpm_edit.LatentDiffusion.apply_model', apply_model, unet_needs_upcast)
-
-
-unet_needs_upcast = lambda *args, **kwargs: devices.unet_needs_upcast
-CondFunc('ldm.models.diffusion.ddpm.LatentDiffusion.apply_model', apply_model, unet_needs_upcast)
-CondFunc('ldm.modules.diffusionmodules.openaimodel.timestep_embedding', lambda orig_func, timesteps, *args, **kwargs: orig_func(timesteps, *args, **kwargs).to(torch.float32 if timesteps.dtype == torch.int64 else devices.dtype_unet), unet_needs_upcast)
-if version.parse(torch.__version__) <= version.parse("1.13.1"):
-    CondFunc('ldm.modules.diffusionmodules.util.GroupNorm32.forward', lambda orig_func, self, *args, **kwargs: orig_func(self.float(), *args, **kwargs), unet_needs_upcast)
-    CondFunc('ldm.modules.attention.GEGLU.forward', lambda orig_func, self, x: orig_func(self.float(), x.float()).to(devices.dtype_unet), unet_needs_upcast)
-    CondFunc('open_clip.transformer.ResidualAttentionBlock.__init__', lambda orig_func, *args, **kwargs: kwargs.update({'act_layer': GELUHijack}) and False or orig_func(*args, **kwargs), lambda _, *args, **kwargs: kwargs.get('act_layer') is None or kwargs['act_layer'] == torch.nn.GELU)
-
-first_stage_cond = lambda _, self, *args, **kwargs: devices.unet_needs_upcast and self.model.diffusion_model.dtype == torch.float16
-first_stage_sub = lambda orig_func, self, x, **kwargs: orig_func(self, x.to(devices.dtype_vae), **kwargs)
-CondFunc('ldm.models.diffusion.ddpm.LatentDiffusion.decode_first_stage', first_stage_sub, first_stage_cond)
-CondFunc('ldm.models.diffusion.ddpm.LatentDiffusion.encode_first_stage', first_stage_sub, first_stage_cond)
-CondFunc('ldm.models.diffusion.ddpm.LatentDiffusion.get_first_stage_encoding', lambda orig_func, *args, **kwargs: orig_func(*args, **kwargs).float(), first_stage_cond)
diff --git a/spaces/vaishanthr/Simultaneous-Segmented-Depth-Prediction/yolov8/docs/yolov5/tutorials/model_pruning_and_sparsity.md b/spaces/vaishanthr/Simultaneous-Segmented-Depth-Prediction/yolov8/docs/yolov5/tutorials/model_pruning_and_sparsity.md
deleted file mode 100644
index 25e4f8c300a364ad008007628799cfc738752829..0000000000000000000000000000000000000000
--- a/spaces/vaishanthr/Simultaneous-Segmented-Depth-Prediction/yolov8/docs/yolov5/tutorials/model_pruning_and_sparsity.md
+++ /dev/null
@@ -1,110 +0,0 @@
----
-comments: true
-description: Learn how to apply pruning to your YOLOv5 models. See the before and after performance with an explanation of sparsity and more.
-keywords: YOLOv5, ultralytics, pruning, deep learning, computer vision, object detection, AI, tutorial
----
-
-📚 This guide explains how to apply **pruning** to YOLOv5 🚀 models.  
-UPDATED 25 September 2022.
-
-## Before You Start
-
-Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.7.0**](https://www.python.org/) environment, including [**PyTorch>=1.7**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
-
-```bash
-git clone https://github.com/ultralytics/yolov5  # clone
-cd yolov5
-pip install -r requirements.txt  # install
-```
-
-## Test Normally
-
-Before pruning we want to establish a baseline performance to compare to. This command tests YOLOv5x on COCO val2017 at image size 640 pixels. `yolov5x.pt` is the largest and most accurate model available. Other options are `yolov5s.pt`, `yolov5m.pt` and `yolov5l.pt`, or you own checkpoint from training a custom dataset `./weights/best.pt`. For details on all available models please see our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints).
-
-```bash
-python val.py --weights yolov5x.pt --data coco.yaml --img 640 --half
-```
-
-Output:
-
-```shell
-val: data=/content/yolov5/data/coco.yaml, weights=['yolov5x.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.65, task=val, device=, workers=8, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True, dnn=False
-YOLOv5 🚀 v6.0-224-g4c40933 torch 1.10.0+cu111 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)
-
-Fusing layers... 
-Model Summary: 444 layers, 86705005 parameters, 0 gradients
-val: Scanning '/content/datasets/coco/val2017.cache' images and labels... 4952 found, 48 missing, 0 empty, 0 corrupt: 100% 5000/5000 [00:00<?, ?it/s]
-               Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100% 157/157 [01:12<00:00,  2.16it/s]
-                 all       5000      36335      0.732      0.628      0.683      0.496
-Speed: 0.1ms pre-process, 5.2ms inference, 1.7ms NMS per image at shape (32, 3, 640, 640)  # <--- base speed
-
-Evaluating pycocotools mAP... saving runs/val/exp2/yolov5x_predictions.json...
-...
- Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.507  # <--- base mAP
- Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.689
- Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.552
- Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.345
- Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.559
- Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.652
- Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.381
- Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.630
- Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.682
- Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.526
- Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.731
- Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.829
-Results saved to runs/val/exp
-```
-
-## Test YOLOv5x on COCO (0.30 sparsity)
-
-We repeat the above test with a pruned model by using the `torch_utils.prune()` command. We update `val.py` to prune YOLOv5x to 0.3 sparsity:
-
-<img width="894" alt="Screenshot 2022-02-02 at 22 54 18" src="https://user-images.githubusercontent.com/26833433/152243799-b0ac2777-b1a8-47b1-801a-2e4c93c06ead.png">
-
-30% pruned output:
-
-```bash
-val: data=/content/yolov5/data/coco.yaml, weights=['yolov5x.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.65, task=val, device=, workers=8, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True, dnn=False
-YOLOv5 🚀 v6.0-224-g4c40933 torch 1.10.0+cu111 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)
-
-Fusing layers... 
-Model Summary: 444 layers, 86705005 parameters, 0 gradients
-Pruning model...  0.3 global sparsity
-val: Scanning '/content/datasets/coco/val2017.cache' images and labels... 4952 found, 48 missing, 0 empty, 0 corrupt: 100% 5000/5000 [00:00<?, ?it/s]
-               Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100% 157/157 [01:11<00:00,  2.19it/s]
-                 all       5000      36335      0.724      0.614      0.671      0.478
-Speed: 0.1ms pre-process, 5.2ms inference, 1.7ms NMS per image at shape (32, 3, 640, 640)  # <--- prune mAP
-
-Evaluating pycocotools mAP... saving runs/val/exp3/yolov5x_predictions.json...
-...
- Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.489  # <--- prune mAP
- Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.677
- Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.537
- Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.334
- Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.542
- Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.635
- Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.370
- Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.612
- Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.664
- Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.496
- Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.722
- Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.803
-Results saved to runs/val/exp3
-```
-
-In the results we can observe that we have achieved a **sparsity of 30%** in our model after pruning, which means that 30% of the model's weight parameters in `nn.Conv2d` layers are equal to 0. **Inference time is essentially unchanged**, while the model's **AP and AR scores a slightly reduced**.
-
-## Environments
-
-YOLOv5 is designed to be run in the following up-to-date verified environments (with all dependencies including [CUDA](https://developer.nvidia.com/cuda)/[CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/) and [PyTorch](https://pytorch.org/) preinstalled):
-
-- **Notebooks** with free GPU: <a href="https://bit.ly/yolov5-paperspace-notebook"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Run on Gradient"></a> <a href="https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a> <a href="https://www.kaggle.com/ultralytics/yolov5"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>
-- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
-- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
-- **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/) <a href="https://hub.docker.com/r/ultralytics/yolov5"><img src="https://img.shields.io/docker/pulls/ultralytics/yolov5?logo=docker" alt="Docker Pulls"></a>
-
-## Status
-
-<a href="https://github.com/ultralytics/yolov5/actions/workflows/ci-testing.yml"><img src="https://github.com/ultralytics/yolov5/actions/workflows/ci-testing.yml/badge.svg" alt="YOLOv5 CI"></a>
-
-If this badge is green, all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are currently passing. CI tests verify correct operation of YOLOv5 [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py) and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
\ No newline at end of file
diff --git a/spaces/vinthony/SadTalker/src/audio2pose_models/audio_encoder.py b/spaces/vinthony/SadTalker/src/audio2pose_models/audio_encoder.py
deleted file mode 100644
index 6279d2014a2e786a6c549f084339e18d00e50331..0000000000000000000000000000000000000000
--- a/spaces/vinthony/SadTalker/src/audio2pose_models/audio_encoder.py
+++ /dev/null
@@ -1,64 +0,0 @@
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-class Conv2d(nn.Module):
-    def __init__(self, cin, cout, kernel_size, stride, padding, residual=False, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.conv_block = nn.Sequential(
-                            nn.Conv2d(cin, cout, kernel_size, stride, padding),
-                            nn.BatchNorm2d(cout)
-                            )
-        self.act = nn.ReLU()
-        self.residual = residual
-
-    def forward(self, x):
-        out = self.conv_block(x)
-        if self.residual:
-            out += x
-        return self.act(out)
-
-class AudioEncoder(nn.Module):
-    def __init__(self, wav2lip_checkpoint, device):
-        super(AudioEncoder, self).__init__()
-
-        self.audio_encoder = nn.Sequential(
-            Conv2d(1, 32, kernel_size=3, stride=1, padding=1),
-            Conv2d(32, 32, kernel_size=3, stride=1, padding=1, residual=True),
-            Conv2d(32, 32, kernel_size=3, stride=1, padding=1, residual=True),
-
-            Conv2d(32, 64, kernel_size=3, stride=(3, 1), padding=1),
-            Conv2d(64, 64, kernel_size=3, stride=1, padding=1, residual=True),
-            Conv2d(64, 64, kernel_size=3, stride=1, padding=1, residual=True),
-
-            Conv2d(64, 128, kernel_size=3, stride=3, padding=1),
-            Conv2d(128, 128, kernel_size=3, stride=1, padding=1, residual=True),
-            Conv2d(128, 128, kernel_size=3, stride=1, padding=1, residual=True),
-
-            Conv2d(128, 256, kernel_size=3, stride=(3, 2), padding=1),
-            Conv2d(256, 256, kernel_size=3, stride=1, padding=1, residual=True),
-
-            Conv2d(256, 512, kernel_size=3, stride=1, padding=0),
-            Conv2d(512, 512, kernel_size=1, stride=1, padding=0),)
-
-        #### load the pre-trained audio_encoder, we do not need to load wav2lip model here.
-        # wav2lip_state_dict = torch.load(wav2lip_checkpoint, map_location=torch.device(device))['state_dict']
-        # state_dict = self.audio_encoder.state_dict()
-
-        # for k,v in wav2lip_state_dict.items():
-        #     if 'audio_encoder' in k:
-        #         state_dict[k.replace('module.audio_encoder.', '')] = v
-        # self.audio_encoder.load_state_dict(state_dict)
-
-
-    def forward(self, audio_sequences):
-        # audio_sequences = (B, T, 1, 80, 16)
-        B = audio_sequences.size(0)
-
-        audio_sequences = torch.cat([audio_sequences[:, i] for i in range(audio_sequences.size(1))], dim=0)
-
-        audio_embedding = self.audio_encoder(audio_sequences) # B, 512, 1, 1
-        dim = audio_embedding.shape[1]
-        audio_embedding = audio_embedding.reshape((B, -1, dim, 1, 1))
-
-        return audio_embedding.squeeze(-1).squeeze(-1) #B seq_len+1 512 
diff --git a/spaces/vumichien/Generate_human_motion/VQ-Trans/utils/utils_model.py b/spaces/vumichien/Generate_human_motion/VQ-Trans/utils/utils_model.py
deleted file mode 100644
index b3653a47ddb96f2ba27aae73b4eef8be904e9bf0..0000000000000000000000000000000000000000
--- a/spaces/vumichien/Generate_human_motion/VQ-Trans/utils/utils_model.py
+++ /dev/null
@@ -1,66 +0,0 @@
-import numpy as np 
-import torch
-import torch.optim as optim
-import logging
-import os 
-import sys 
-
-def getCi(accLog):
-
-    mean = np.mean(accLog)
-    std = np.std(accLog)
-    ci95 = 1.96*std/np.sqrt(len(accLog))
-
-    return mean, ci95
-
-def get_logger(out_dir):
-    logger = logging.getLogger('Exp')
-    logger.setLevel(logging.INFO)
-    formatter = logging.Formatter("%(asctime)s %(levelname)s %(message)s")
-
-    file_path = os.path.join(out_dir, "run.log")
-    file_hdlr = logging.FileHandler(file_path)
-    file_hdlr.setFormatter(formatter)
-
-    strm_hdlr = logging.StreamHandler(sys.stdout)
-    strm_hdlr.setFormatter(formatter)
-
-    logger.addHandler(file_hdlr)
-    logger.addHandler(strm_hdlr)
-    return logger
-
-## Optimizer
-def initial_optim(decay_option, lr, weight_decay, net, optimizer) : 
-    
-    if optimizer == 'adamw' : 
-        optimizer_adam_family = optim.AdamW
-    elif optimizer == 'adam' : 
-        optimizer_adam_family = optim.Adam
-    if decay_option == 'all':
-        #optimizer = optimizer_adam_family(net.parameters(), lr=lr, betas=(0.9, 0.999), weight_decay=weight_decay)
-        optimizer = optimizer_adam_family(net.parameters(), lr=lr, betas=(0.5, 0.9), weight_decay=weight_decay)
-        
-    elif decay_option == 'noVQ':
-        all_params = set(net.parameters())
-        no_decay = set([net.vq_layer])
-        
-        decay = all_params - no_decay
-        optimizer = optimizer_adam_family([
-                    {'params': list(no_decay), 'weight_decay': 0}, 
-                    {'params': list(decay), 'weight_decay' : weight_decay}], lr=lr)
-        
-    return optimizer
-
-
-def get_motion_with_trans(motion, velocity) : 
-    '''
-    motion : torch.tensor, shape (batch_size, T, 72), with the global translation = 0
-    velocity : torch.tensor, shape (batch_size, T, 3), contain the information of velocity = 0
-    
-    '''
-    trans = torch.cumsum(velocity, dim=1)
-    trans = trans - trans[:, :1] ## the first root is initialized at 0 (just for visualization)
-    trans = trans.repeat((1, 1, 21))
-    motion_with_trans = motion + trans
-    return motion_with_trans
-    
\ No newline at end of file
diff --git a/spaces/weiren119/AudiogramDigitization/models/labels/format_dataset.py b/spaces/weiren119/AudiogramDigitization/models/labels/format_dataset.py
deleted file mode 100644
index 2d7e19b7f43d37d418c1a2796d26b5c669eda928..0000000000000000000000000000000000000000
--- a/spaces/weiren119/AudiogramDigitization/models/labels/format_dataset.py
+++ /dev/null
@@ -1,183 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copyright (c) 2020 Carleton University Biomedical Informatics Collaboratory
-
-This source code is licensed under the MIT license found in the
-LICENSE file in the root directory of this source tree.
-"""
-from typing import List
-from types import SimpleNamespace
-import argparse, os, json, shutil
-from tqdm import tqdm
-import os.path as path
-import numpy as np
-from PIL import Image
-
-LABEL_CLASS_INDICES = {
-    "250": 0,
-    ".25": 1,
-    "500": 2,
-    ".5": 3,
-    "1000": 4,
-    "1": 5,
-    "1K": 6,
-    "2000": 7,
-    "2": 8,
-    "2K": 9,
-    "4000": 10,
-    "4": 11,
-    "4K": 12,
-    "8000": 13,
-    "8": 14,
-    "8K": 15,
-    "0": 16,
-    "20": 17,
-    "40": 18,
-    "60": 19,
-    "80": 20,
-    "100": 21,
-    "120": 22
-}
-
-def extract_labels(annotation: dict, image: Image) -> List[tuple]:
-    """Extracts the bounding boxes of labels into a tuple compatible
-    the YOLOv5 format.
-
-    Parameters
-    ----------
-    annotation : dict
-    A dictionary containing the annotations for the audiograms in a report.
-
-    image : Image
-    The image in PIL format corresponding to the annotation.
-
-    Returns
-    -------
-    tuple
-    A tuple of the form
-    (class index, x_center, y_center, width, height) where all coordinates
-    and dimensions are normalized to the width/height of the image.
-    """
-    label_label_tuples = []
-    image_width, image_height = image.size
-    for audiogram in annotation:
-        for label in audiogram["labels"]:
-            bounding_box = label["boundingBox"]
-            x_center = (bounding_box["x"] + bounding_box["width"] / 2) / image_width
-            y_center = (bounding_box["y"] + bounding_box["height"] / 2) / image_height
-            box_width = bounding_box["width"] / image_width
-            box_height = bounding_box["height"] / image_width
-            try:
-                label_label_tuples.append((LABEL_CLASS_INDICES[label["value"]], x_center, y_center, box_width, box_height))
-            except:
-                continue
-    return label_label_tuples
-
-def create_directory_structure(data_dir: str):
-    try:
-        shutil.rmtree(path.join(data_dir))
-    except:
-        pass
-    os.mkdir(path.join(data_dir))
-    os.mkdir(path.join(data_dir, "images"))
-    os.mkdir(path.join(data_dir, "images", "train"))
-    os.mkdir(path.join(data_dir, "images", "validation"))
-    os.mkdir(path.join(data_dir, "labels"))
-    os.mkdir(path.join(data_dir, "labels", "train"))
-    os.mkdir(path.join(data_dir, "labels", "validation"))
-
-def create_yolov5_file(bboxes: List[tuple], filename: str):
-    # Turn the bounding boxes into a string with a bounding box
-    # on each line
-    file_content = "\n".join([
-        f"{bbox[0]} {bbox[1]} {bbox[2]} {bbox[3]} {bbox[4]}"
-        for bbox in bboxes
-    ])
-
-    # Save to a file
-    with open(filename, "w") as output_file:
-        output_file.write(file_content)
-
-def all_labels_valid(labels: List[tuple]):
-    for label in labels:
-        for value in label[1:]:
-            if value < 0 or value > 1:
-                return False
-    return True
-
-
-def main(args: SimpleNamespace):
-
-    # Find all the JSON files in the input directory
-    report_ids = [
-        filename.rstrip(".json")
-        for filename in os.listdir(path.join(args.annotations_dir))
-        if filename.endswith(".json")
-        and path.exists(path.join(args.images_dir, filename.rstrip(".json") + ".jpg"))
-    ]
-
-    # Shuffle
-    np.random.seed(seed=42) # for reproducibility of the shuffle
-    np.random.shuffle(report_ids)
-
-    # Create the directory structure in which the images and annotations
-    # are to be stored
-    create_directory_structure(args.data_dir)
-
-    # Iterate through the report ids, extract the annotations in YOLOv5 format
-    # and place the file in the correct directory, and the image in the correct
-    # directory.
-    for i, report_id in enumerate(tqdm(report_ids)):
-
-        # Decide if the image is going into the training set or validation set
-        directory = (
-            "train" if i < args.train_frac * len(report_ids) else "validation"
-        )
-
-        # Load the annotation`
-        annotation_content = open(
-            path.join(args.annotations_dir, f"{report_id}.json")
-        )
-
-        image = Image.open(os.path.join(args.images_dir, f"{report_id}.jpg"))
-
-        annotation = json.load(annotation_content)
-        bounding_boxes = extract_labels(annotation, image)
-
-        if not all_labels_valid(bounding_boxes):
-            continue
-
-        # Open the corresponding image to get its dimensions
-        image = Image.open(os.path.join(args.images_dir, f"{report_id}.jpg"))
-
-        create_yolov5_file(
-            bounding_boxes,
-            path.join(args.data_dir, "labels", directory, f"{report_id}.txt")
-        )
-        image.save(
-            path.join(args.data_dir, "images", directory, f"{report_id}.jpg")
-        )
-
-if __name__ == "__main__":
-    import argparse
-
-    parser = argparse.ArgumentParser(description=(
-        "Script that formats the training set for transfer learning of labels detection via "
-        "the YOLOv5 model."
-    ))
-    parser.add_argument("-d", "--data_dir", type=str, required=True, help=(
-        "Path to the directory where the training set should be created."
-    ))
-    parser.add_argument("-a", "--annotations_dir", type=str, required=True, help=(
-        "Path to the directory containing the annotations in the JSON format." 
-    ))
-    parser.add_argument("-i", "--images_dir", type=str, required=True, help=(
-        "Path to the directory containing the images." 
-    ))
-    parser.add_argument("-f", "--train_frac", type=float, required=True, help=(
-        "Fraction of images to be used for training. (e.g. 0.8)"
-    ))
-    args = parser.parse_args()
-
-    main(args)
-
diff --git a/spaces/wendys-llc/panoptic-segment-anything/GroundingDINO/groundingdino/models/GroundingDINO/fuse_modules.py b/spaces/wendys-llc/panoptic-segment-anything/GroundingDINO/groundingdino/models/GroundingDINO/fuse_modules.py
deleted file mode 100644
index 2753b3ddee43c7a9fe28d1824db5d786e7e1ad59..0000000000000000000000000000000000000000
--- a/spaces/wendys-llc/panoptic-segment-anything/GroundingDINO/groundingdino/models/GroundingDINO/fuse_modules.py
+++ /dev/null
@@ -1,297 +0,0 @@
-# ------------------------------------------------------------------------
-# Grounding DINO
-# url: https://github.com/IDEA-Research/GroundingDINO
-# Copyright (c) 2023 IDEA. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-# ------------------------------------------------------------------------
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from timm.models.layers import DropPath
-
-
-class FeatureResizer(nn.Module):
-    """
-    This class takes as input a set of embeddings of dimension C1 and outputs a set of
-    embedding of dimension C2, after a linear transformation, dropout and normalization (LN).
-    """
-
-    def __init__(self, input_feat_size, output_feat_size, dropout, do_ln=True):
-        super().__init__()
-        self.do_ln = do_ln
-        # Object feature encoding
-        self.fc = nn.Linear(input_feat_size, output_feat_size, bias=True)
-        self.layer_norm = nn.LayerNorm(output_feat_size, eps=1e-12)
-        self.dropout = nn.Dropout(dropout)
-
-    def forward(self, encoder_features):
-        x = self.fc(encoder_features)
-        if self.do_ln:
-            x = self.layer_norm(x)
-        output = self.dropout(x)
-        return output
-
-
-def l1norm(X, dim, eps=1e-8):
-    """L1-normalize columns of X"""
-    norm = torch.abs(X).sum(dim=dim, keepdim=True) + eps
-    X = torch.div(X, norm)
-    return X
-
-
-def l2norm(X, dim, eps=1e-8):
-    """L2-normalize columns of X"""
-    norm = torch.pow(X, 2).sum(dim=dim, keepdim=True).sqrt() + eps
-    X = torch.div(X, norm)
-    return X
-
-
-def func_attention(query, context, smooth=1, raw_feature_norm="softmax", eps=1e-8):
-    """
-    query: (n_context, queryL, d)
-    context: (n_context, sourceL, d)
-    """
-    batch_size_q, queryL = query.size(0), query.size(1)
-    batch_size, sourceL = context.size(0), context.size(1)
-
-    # Get attention
-    # --> (batch, d, queryL)
-    queryT = torch.transpose(query, 1, 2)
-
-    # (batch, sourceL, d)(batch, d, queryL)
-    # --> (batch, sourceL, queryL)
-    attn = torch.bmm(context, queryT)
-    if raw_feature_norm == "softmax":
-        # --> (batch*sourceL, queryL)
-        attn = attn.view(batch_size * sourceL, queryL)
-        attn = nn.Softmax()(attn)
-        # --> (batch, sourceL, queryL)
-        attn = attn.view(batch_size, sourceL, queryL)
-    elif raw_feature_norm == "l2norm":
-        attn = l2norm(attn, 2)
-    elif raw_feature_norm == "clipped_l2norm":
-        attn = nn.LeakyReLU(0.1)(attn)
-        attn = l2norm(attn, 2)
-    else:
-        raise ValueError("unknown first norm type:", raw_feature_norm)
-    # --> (batch, queryL, sourceL)
-    attn = torch.transpose(attn, 1, 2).contiguous()
-    # --> (batch*queryL, sourceL)
-    attn = attn.view(batch_size * queryL, sourceL)
-    attn = nn.Softmax()(attn * smooth)
-    # --> (batch, queryL, sourceL)
-    attn = attn.view(batch_size, queryL, sourceL)
-    # --> (batch, sourceL, queryL)
-    attnT = torch.transpose(attn, 1, 2).contiguous()
-
-    # --> (batch, d, sourceL)
-    contextT = torch.transpose(context, 1, 2)
-    # (batch x d x sourceL)(batch x sourceL x queryL)
-    # --> (batch, d, queryL)
-    weightedContext = torch.bmm(contextT, attnT)
-    # --> (batch, queryL, d)
-    weightedContext = torch.transpose(weightedContext, 1, 2)
-
-    return weightedContext, attnT
-
-
-class BiMultiHeadAttention(nn.Module):
-    def __init__(self, v_dim, l_dim, embed_dim, num_heads, dropout=0.1, cfg=None):
-        super(BiMultiHeadAttention, self).__init__()
-
-        self.embed_dim = embed_dim
-        self.num_heads = num_heads
-        self.head_dim = embed_dim // num_heads
-        self.v_dim = v_dim
-        self.l_dim = l_dim
-
-        assert (
-            self.head_dim * self.num_heads == self.embed_dim
-        ), f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`: {self.num_heads})."
-        self.scale = self.head_dim ** (-0.5)
-        self.dropout = dropout
-
-        self.v_proj = nn.Linear(self.v_dim, self.embed_dim)
-        self.l_proj = nn.Linear(self.l_dim, self.embed_dim)
-        self.values_v_proj = nn.Linear(self.v_dim, self.embed_dim)
-        self.values_l_proj = nn.Linear(self.l_dim, self.embed_dim)
-
-        self.out_v_proj = nn.Linear(self.embed_dim, self.v_dim)
-        self.out_l_proj = nn.Linear(self.embed_dim, self.l_dim)
-
-        self.stable_softmax_2d = True
-        self.clamp_min_for_underflow = True
-        self.clamp_max_for_overflow = True
-
-        self._reset_parameters()
-
-    def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
-        return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
-
-    def _reset_parameters(self):
-        nn.init.xavier_uniform_(self.v_proj.weight)
-        self.v_proj.bias.data.fill_(0)
-        nn.init.xavier_uniform_(self.l_proj.weight)
-        self.l_proj.bias.data.fill_(0)
-        nn.init.xavier_uniform_(self.values_v_proj.weight)
-        self.values_v_proj.bias.data.fill_(0)
-        nn.init.xavier_uniform_(self.values_l_proj.weight)
-        self.values_l_proj.bias.data.fill_(0)
-        nn.init.xavier_uniform_(self.out_v_proj.weight)
-        self.out_v_proj.bias.data.fill_(0)
-        nn.init.xavier_uniform_(self.out_l_proj.weight)
-        self.out_l_proj.bias.data.fill_(0)
-
-    def forward(self, v, l, attention_mask_v=None, attention_mask_l=None):
-        """_summary_
-
-        Args:
-            v (_type_): bs, n_img, dim
-            l (_type_): bs, n_text, dim
-            attention_mask_v (_type_, optional): _description_. bs, n_img
-            attention_mask_l (_type_, optional): _description_. bs, n_text
-
-        Returns:
-            _type_: _description_
-        """
-        # if os.environ.get('IPDB_SHILONG_DEBUG', None) == 'INFO':
-        #     import ipdb; ipdb.set_trace()
-        bsz, tgt_len, _ = v.size()
-
-        query_states = self.v_proj(v) * self.scale
-        key_states = self._shape(self.l_proj(l), -1, bsz)
-        value_v_states = self._shape(self.values_v_proj(v), -1, bsz)
-        value_l_states = self._shape(self.values_l_proj(l), -1, bsz)
-
-        proj_shape = (bsz * self.num_heads, -1, self.head_dim)
-        query_states = self._shape(query_states, tgt_len, bsz).view(*proj_shape)
-        key_states = key_states.view(*proj_shape)
-        value_v_states = value_v_states.view(*proj_shape)
-        value_l_states = value_l_states.view(*proj_shape)
-
-        src_len = key_states.size(1)
-        attn_weights = torch.bmm(query_states, key_states.transpose(1, 2))  # bs*nhead, nimg, ntxt
-
-        if attn_weights.size() != (bsz * self.num_heads, tgt_len, src_len):
-            raise ValueError(
-                f"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is {attn_weights.size()}"
-            )
-
-        if self.stable_softmax_2d:
-            attn_weights = attn_weights - attn_weights.max()
-
-        if self.clamp_min_for_underflow:
-            attn_weights = torch.clamp(
-                attn_weights, min=-50000
-            )  # Do not increase -50000, data type half has quite limited range
-        if self.clamp_max_for_overflow:
-            attn_weights = torch.clamp(
-                attn_weights, max=50000
-            )  # Do not increase 50000, data type half has quite limited range
-
-        attn_weights_T = attn_weights.transpose(1, 2)
-        attn_weights_l = attn_weights_T - torch.max(attn_weights_T, dim=-1, keepdim=True)[0]
-        if self.clamp_min_for_underflow:
-            attn_weights_l = torch.clamp(
-                attn_weights_l, min=-50000
-            )  # Do not increase -50000, data type half has quite limited range
-        if self.clamp_max_for_overflow:
-            attn_weights_l = torch.clamp(
-                attn_weights_l, max=50000
-            )  # Do not increase 50000, data type half has quite limited range
-
-        # mask vison for language
-        if attention_mask_v is not None:
-            attention_mask_v = (
-                attention_mask_v[:, None, None, :].repeat(1, self.num_heads, 1, 1).flatten(0, 1)
-            )
-            attn_weights_l.masked_fill_(attention_mask_v, float("-inf"))
-
-        attn_weights_l = attn_weights_l.softmax(dim=-1)
-
-        # mask language for vision
-        if attention_mask_l is not None:
-            attention_mask_l = (
-                attention_mask_l[:, None, None, :].repeat(1, self.num_heads, 1, 1).flatten(0, 1)
-            )
-            attn_weights.masked_fill_(attention_mask_l, float("-inf"))
-        attn_weights_v = attn_weights.softmax(dim=-1)
-
-        attn_probs_v = F.dropout(attn_weights_v, p=self.dropout, training=self.training)
-        attn_probs_l = F.dropout(attn_weights_l, p=self.dropout, training=self.training)
-
-        attn_output_v = torch.bmm(attn_probs_v, value_l_states)
-        attn_output_l = torch.bmm(attn_probs_l, value_v_states)
-
-        if attn_output_v.size() != (bsz * self.num_heads, tgt_len, self.head_dim):
-            raise ValueError(
-                f"`attn_output_v` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {attn_output_v.size()}"
-            )
-
-        if attn_output_l.size() != (bsz * self.num_heads, src_len, self.head_dim):
-            raise ValueError(
-                f"`attn_output_l` should be of size {(bsz, self.num_heads, src_len, self.head_dim)}, but is {attn_output_l.size()}"
-            )
-
-        attn_output_v = attn_output_v.view(bsz, self.num_heads, tgt_len, self.head_dim)
-        attn_output_v = attn_output_v.transpose(1, 2)
-        attn_output_v = attn_output_v.reshape(bsz, tgt_len, self.embed_dim)
-
-        attn_output_l = attn_output_l.view(bsz, self.num_heads, src_len, self.head_dim)
-        attn_output_l = attn_output_l.transpose(1, 2)
-        attn_output_l = attn_output_l.reshape(bsz, src_len, self.embed_dim)
-
-        attn_output_v = self.out_v_proj(attn_output_v)
-        attn_output_l = self.out_l_proj(attn_output_l)
-
-        return attn_output_v, attn_output_l
-
-
-# Bi-Direction MHA (text->image, image->text)
-class BiAttentionBlock(nn.Module):
-    def __init__(
-        self,
-        v_dim,
-        l_dim,
-        embed_dim,
-        num_heads,
-        dropout=0.1,
-        drop_path=0.0,
-        init_values=1e-4,
-        cfg=None,
-    ):
-        """
-        Inputs:
-            embed_dim - Dimensionality of input and attention feature vectors
-            hidden_dim - Dimensionality of hidden layer in feed-forward network
-                         (usually 2-4x larger than embed_dim)
-            num_heads - Number of heads to use in the Multi-Head Attention block
-            dropout - Amount of dropout to apply in the feed-forward network
-        """
-        super(BiAttentionBlock, self).__init__()
-
-        # pre layer norm
-        self.layer_norm_v = nn.LayerNorm(v_dim)
-        self.layer_norm_l = nn.LayerNorm(l_dim)
-        self.attn = BiMultiHeadAttention(
-            v_dim=v_dim, l_dim=l_dim, embed_dim=embed_dim, num_heads=num_heads, dropout=dropout
-        )
-
-        # add layer scale for training stability
-        self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
-        self.gamma_v = nn.Parameter(init_values * torch.ones((v_dim)), requires_grad=True)
-        self.gamma_l = nn.Parameter(init_values * torch.ones((l_dim)), requires_grad=True)
-
-    def forward(self, v, l, attention_mask_v=None, attention_mask_l=None):
-        v = self.layer_norm_v(v)
-        l = self.layer_norm_l(l)
-        delta_v, delta_l = self.attn(
-            v, l, attention_mask_v=attention_mask_v, attention_mask_l=attention_mask_l
-        )
-        # v, l = v + delta_v, l + delta_l
-        v = v + self.drop_path(self.gamma_v * delta_v)
-        l = l + self.drop_path(self.gamma_l * delta_l)
-        return v, l
-
-    # def forward(self, v:List[torch.Tensor], l, attention_mask_v=None, attention_mask_l=None)
diff --git a/spaces/whoisterencelee/stabilityai-FreeWilly2/README.md b/spaces/whoisterencelee/stabilityai-FreeWilly2/README.md
deleted file mode 100644
index ae416a8ae18e177ddce4443e61b82dae193d2527..0000000000000000000000000000000000000000
--- a/spaces/whoisterencelee/stabilityai-FreeWilly2/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Stabilityai FreeWilly2
-emoji: 🦀
-colorFrom: indigo
-colorTo: green
-sdk: gradio
-sdk_version: 3.38.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/williamcfrancis/Deep-Blind-Motion-Deblurring/create_blurred.py b/spaces/williamcfrancis/Deep-Blind-Motion-Deblurring/create_blurred.py
deleted file mode 100644
index f1eaf459990d1539b42e8055052527cc511bdd34..0000000000000000000000000000000000000000
--- a/spaces/williamcfrancis/Deep-Blind-Motion-Deblurring/create_blurred.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import numpy as np
-import os
-import cv2
-import random
-import json
-import argparse
-
-ap= argparse.ArgumentParser()
-ap.add_argument('--input_dir', '-i', required=True, help='Path to input dir for images')
-ap.add_argument('--output_dir', '-o', required=True, help='Path to output dir to store files. Must be created')
-ap.add_argument('--max_imgs', '-m', default=20000, type=int, help='Max number of images to generate')
-
-args= vars(ap.parse_args())
-
-def apply_motion_blur(image, size, angle):
-	k = np.zeros((size, size), dtype=np.float32)
-	k[ (size-1)// 2 , :] = np.ones(size, dtype=np.float32)
-	k = cv2.warpAffine(k, cv2.getRotationMatrix2D( (size / 2 -0.5 , size / 2 -0.5 ) , angle, 1.0), (size, size) )  
-	k = k * ( 1.0 / np.sum(k) )        
-	return cv2.filter2D(image, -1, k) 
-
-
-folder = args['input_dir']
-folder_save = args['output_dir']
-max_images = args['max_imgs']
-
-print(max_images)
-
-
-labels_angle = {}
-labels_length= {}
-images_done = 0
-for filename in os.listdir(folder):
-	img = cv2.imread(os.path.join(folder,filename))
-	if img is not None and img.shape[1] > img.shape[0]:
-		img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-		img_resized = cv2.resize(img_gray, (640,480), interpolation = cv2.INTER_AREA)
-		length = random.randint(20,40)
-		angle = random.randint(0,359)
-		blurred = apply_motion_blur(img_resized, length, angle)
-		cv2.imwrite(os.path.join(folder_save,filename), blurred)
-		if angle>=180:
-			angle_a= angle - 180
-		else:
-			angle_a= angle
-		labels_angle[filename] = angle_a
-		labels_length[filename]= length
-		images_done += 1
-		print("%s done"%images_done)
-		if(images_done == max_images):
-			print('Done!!!')
-			break
-
-with open('angle_labels.json', 'w') as file:
-	json.dump(labels_angle, file)
-with open('length_labels.json', 'w') as file:
-	json.dump(labels_length, file)
-    
-
diff --git a/spaces/wuhuik/bingo/src/components/turn-counter.tsx b/spaces/wuhuik/bingo/src/components/turn-counter.tsx
deleted file mode 100644
index 08a9e488f044802a8600f4d195b106567c35aab4..0000000000000000000000000000000000000000
--- a/spaces/wuhuik/bingo/src/components/turn-counter.tsx
+++ /dev/null
@@ -1,23 +0,0 @@
-import React from 'react'
-import { Throttling } from '@/lib/bots/bing/types'
-
-export interface TurnCounterProps {
-  throttling?: Throttling
-}
-
-export function TurnCounter({ throttling }: TurnCounterProps) {
-  if (!throttling) {
-    return null
-  }
-
-  return (
-    <div className="turn-counter">
-      <div className="text">
-        <span>{throttling.numUserMessagesInConversation}</span>
-        <span> 共 </span>
-        <span>{throttling.maxNumUserMessagesInConversation}</span>
-      </div>
-      <div className="indicator"></div>
-    </div>
-  )
-}
diff --git a/spaces/xfys/yolov5_tracking/trackers/ocsort/ocsort.py b/spaces/xfys/yolov5_tracking/trackers/ocsort/ocsort.py
deleted file mode 100644
index 11ea1fc60c1254ae6b58fd30027a5a2c4872c548..0000000000000000000000000000000000000000
--- a/spaces/xfys/yolov5_tracking/trackers/ocsort/ocsort.py
+++ /dev/null
@@ -1,327 +0,0 @@
-"""
-    This script is adopted from the SORT script by Alex Bewley alex@bewley.ai
-"""
-from __future__ import print_function
-
-import numpy as np
-from .association import *
-from yolov5.utils.general import xywh2xyxy
-
-
-def k_previous_obs(observations, cur_age, k):
-    if len(observations) == 0:
-        return [-1, -1, -1, -1, -1]
-    for i in range(k):
-        dt = k - i
-        if cur_age - dt in observations:
-            return observations[cur_age-dt]
-    max_age = max(observations.keys())
-    return observations[max_age]
-
-
-def convert_bbox_to_z(bbox):
-    """
-    Takes a bounding box in the form [x1,y1,x2,y2] and returns z in the form
-      [x,y,s,r] where x,y is the centre of the box and s is the scale/area and r is
-      the aspect ratio
-    """
-    w = bbox[2] - bbox[0]
-    h = bbox[3] - bbox[1]
-    x = bbox[0] + w/2.
-    y = bbox[1] + h/2.
-    s = w * h  # scale is just area
-    r = w / float(h+1e-6)
-    return np.array([x, y, s, r]).reshape((4, 1))
-
-
-def convert_x_to_bbox(x, score=None):
-    """
-    Takes a bounding box in the centre form [x,y,s,r] and returns it in the form
-      [x1,y1,x2,y2] where x1,y1 is the top left and x2,y2 is the bottom right
-    """
-    w = np.sqrt(x[2] * x[3])
-    h = x[2] / w
-    if(score == None):
-      return np.array([x[0]-w/2., x[1]-h/2., x[0]+w/2., x[1]+h/2.]).reshape((1, 4))
-    else:
-      return np.array([x[0]-w/2., x[1]-h/2., x[0]+w/2., x[1]+h/2., score]).reshape((1, 5))
-
-
-def speed_direction(bbox1, bbox2):
-    cx1, cy1 = (bbox1[0]+bbox1[2]) / 2.0, (bbox1[1]+bbox1[3])/2.0
-    cx2, cy2 = (bbox2[0]+bbox2[2]) / 2.0, (bbox2[1]+bbox2[3])/2.0
-    speed = np.array([cy2-cy1, cx2-cx1])
-    norm = np.sqrt((cy2-cy1)**2 + (cx2-cx1)**2) + 1e-6
-    return speed / norm
-
-
-class KalmanBoxTracker(object):
-    """
-    This class represents the internal state of individual tracked objects observed as bbox.
-    """
-    count = 0
-
-    def __init__(self, bbox, cls, delta_t=3, orig=False):
-        """
-        Initialises a tracker using initial bounding box.
-
-        """
-        # define constant velocity model
-        if not orig:
-          from .kalmanfilter import KalmanFilterNew as KalmanFilter
-          self.kf = KalmanFilter(dim_x=7, dim_z=4)
-        else:
-          from filterpy.kalman import KalmanFilter
-          self.kf = KalmanFilter(dim_x=7, dim_z=4)
-        self.kf.F = np.array([[1, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 1], [
-                            0, 0, 0, 1, 0, 0, 0],  [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1]])
-        self.kf.H = np.array([[1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0],
-                            [0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0]])
-
-        self.kf.R[2:, 2:] *= 10.
-        self.kf.P[4:, 4:] *= 1000.  # give high uncertainty to the unobservable initial velocities
-        self.kf.P *= 10.
-        self.kf.Q[-1, -1] *= 0.01
-        self.kf.Q[4:, 4:] *= 0.01
-
-        self.kf.x[:4] = convert_bbox_to_z(bbox)
-        self.time_since_update = 0
-        self.id = KalmanBoxTracker.count
-        KalmanBoxTracker.count += 1
-        self.history = []
-        self.hits = 0
-        self.hit_streak = 0
-        self.age = 0
-        #self.conf = conf
-        self.cls = cls
-        """
-        NOTE: [-1,-1,-1,-1,-1] is a compromising placeholder for non-observation status, the same for the return of 
-        function k_previous_obs. It is ugly and I do not like it. But to support generate observation array in a 
-        fast and unified way, which you would see below k_observations = np.array([k_previous_obs(...]]), let's bear it for now.
-        """
-        self.last_observation = np.array([-1, -1, -1, -1, -1])  # placeholder
-        self.observations = dict()
-        self.history_observations = []
-        self.velocity = None
-        self.delta_t = delta_t
-
-    def update(self, bbox, cls):
-        """
-        Updates the state vector with observed bbox.
-        """
-        
-        if bbox is not None:
-            self.cls = cls
-            if self.last_observation.sum() >= 0:  # no previous observation
-                previous_box = None
-                for i in range(self.delta_t):
-                    dt = self.delta_t - i
-                    if self.age - dt in self.observations:
-                        previous_box = self.observations[self.age-dt]
-                        break
-                if previous_box is None:
-                    previous_box = self.last_observation
-                """
-                  Estimate the track speed direction with observations \Delta t steps away
-                """
-                self.velocity = speed_direction(previous_box, bbox)
-            
-            """
-              Insert new observations. This is a ugly way to maintain both self.observations
-              and self.history_observations. Bear it for the moment.
-            """
-            self.last_observation = bbox
-            self.observations[self.age] = bbox
-            self.history_observations.append(bbox)
-
-            self.time_since_update = 0
-            self.history = []
-            self.hits += 1
-            self.hit_streak += 1
-            self.kf.update(convert_bbox_to_z(bbox))
-        else:
-            self.kf.update(bbox)
-
-    def predict(self):
-        """
-        Advances the state vector and returns the predicted bounding box estimate.
-        """
-        if((self.kf.x[6]+self.kf.x[2]) <= 0):
-            self.kf.x[6] *= 0.0
-
-        self.kf.predict()
-        self.age += 1
-        if(self.time_since_update > 0):
-            self.hit_streak = 0
-        self.time_since_update += 1
-        self.history.append(convert_x_to_bbox(self.kf.x))
-        return self.history[-1]
-
-    def get_state(self):
-        """
-        Returns the current bounding box estimate.
-        """
-        return convert_x_to_bbox(self.kf.x)
-
-
-"""
-    We support multiple ways for association cost calculation, by default
-    we use IoU. GIoU may have better performance in some situations. We note 
-    that we hardly normalize the cost by all methods to (0,1) which may not be 
-    the best practice.
-"""
-ASSO_FUNCS = {  "iou": iou_batch,
-                "giou": giou_batch,
-                "ciou": ciou_batch,
-                "diou": diou_batch,
-                "ct_dist": ct_dist}
-
-
-class OCSort(object):
-    def __init__(self, det_thresh, max_age=30, min_hits=3, 
-        iou_threshold=0.3, delta_t=3, asso_func="iou", inertia=0.2, use_byte=False):
-        """
-        Sets key parameters for SORT
-        """
-        self.max_age = max_age
-        self.min_hits = min_hits
-        self.iou_threshold = iou_threshold
-        self.trackers = []
-        self.frame_count = 0
-        self.det_thresh = det_thresh
-        self.delta_t = delta_t
-        self.asso_func = ASSO_FUNCS[asso_func]
-        self.inertia = inertia
-        self.use_byte = use_byte
-        KalmanBoxTracker.count = 0
-
-    def update(self, dets, _):
-        """
-        Params:
-          dets - a numpy array of detections in the format [[x1,y1,x2,y2,score],[x1,y1,x2,y2,score],...]
-        Requires: this method must be called once for each frame even with empty detections (use np.empty((0, 5)) for frames without detections).
-        Returns the a similar array, where the last column is the object ID.
-        NOTE: The number of objects returned may differ from the number of detections provided.
-        """
-
-        self.frame_count += 1
-        
-        xyxys = dets[:, 0:4]
-        confs = dets[:, 4]
-        clss = dets[:, 5]
-        
-        classes = clss.numpy()
-        xyxys = xyxys.numpy()
-        confs = confs.numpy()
-
-        output_results = np.column_stack((xyxys, confs, classes))
-        
-        inds_low = confs > 0.1
-        inds_high = confs < self.det_thresh
-        inds_second = np.logical_and(inds_low, inds_high)  # self.det_thresh > score > 0.1, for second matching
-        dets_second = output_results[inds_second]  # detections for second matching
-        remain_inds = confs > self.det_thresh
-        dets = output_results[remain_inds]
-
-        # get predicted locations from existing trackers.
-        trks = np.zeros((len(self.trackers), 5))
-        to_del = []
-        ret = []
-        for t, trk in enumerate(trks):
-            pos = self.trackers[t].predict()[0]
-            trk[:] = [pos[0], pos[1], pos[2], pos[3], 0]
-            if np.any(np.isnan(pos)):
-                to_del.append(t)
-        trks = np.ma.compress_rows(np.ma.masked_invalid(trks))
-        for t in reversed(to_del):
-            self.trackers.pop(t)
-
-        velocities = np.array(
-            [trk.velocity if trk.velocity is not None else np.array((0, 0)) for trk in self.trackers])
-        last_boxes = np.array([trk.last_observation for trk in self.trackers])
-        k_observations = np.array(
-            [k_previous_obs(trk.observations, trk.age, self.delta_t) for trk in self.trackers])
-
-        """
-            First round of association
-        """
-        matched, unmatched_dets, unmatched_trks = associate(
-            dets, trks, self.iou_threshold, velocities, k_observations, self.inertia)
-        for m in matched:
-            self.trackers[m[1]].update(dets[m[0], :5], dets[m[0], 5])
-
-        """
-            Second round of associaton by OCR
-        """
-        # BYTE association
-        if self.use_byte and len(dets_second) > 0 and unmatched_trks.shape[0] > 0:
-            u_trks = trks[unmatched_trks]
-            iou_left = self.asso_func(dets_second, u_trks)          # iou between low score detections and unmatched tracks
-            iou_left = np.array(iou_left)
-            if iou_left.max() > self.iou_threshold:
-                """
-                    NOTE: by using a lower threshold, e.g., self.iou_threshold - 0.1, you may
-                    get a higher performance especially on MOT17/MOT20 datasets. But we keep it
-                    uniform here for simplicity
-                """
-                matched_indices = linear_assignment(-iou_left)
-                to_remove_trk_indices = []
-                for m in matched_indices:
-                    det_ind, trk_ind = m[0], unmatched_trks[m[1]]
-                    if iou_left[m[0], m[1]] < self.iou_threshold:
-                        continue
-                    self.trackers[trk_ind].update(dets_second[det_ind, :5], dets_second[det_ind, 5])
-                    to_remove_trk_indices.append(trk_ind)
-                unmatched_trks = np.setdiff1d(unmatched_trks, np.array(to_remove_trk_indices))
-
-        if unmatched_dets.shape[0] > 0 and unmatched_trks.shape[0] > 0:
-            left_dets = dets[unmatched_dets]
-            left_trks = last_boxes[unmatched_trks]
-            iou_left = self.asso_func(left_dets, left_trks)
-            iou_left = np.array(iou_left)
-            if iou_left.max() > self.iou_threshold:
-                """
-                    NOTE: by using a lower threshold, e.g., self.iou_threshold - 0.1, you may
-                    get a higher performance especially on MOT17/MOT20 datasets. But we keep it
-                    uniform here for simplicity
-                """
-                rematched_indices = linear_assignment(-iou_left)
-                to_remove_det_indices = []
-                to_remove_trk_indices = []
-                for m in rematched_indices:
-                    det_ind, trk_ind = unmatched_dets[m[0]], unmatched_trks[m[1]]
-                    if iou_left[m[0], m[1]] < self.iou_threshold:
-                        continue
-                    self.trackers[trk_ind].update(dets[det_ind, :5], dets[det_ind, 5])
-                    to_remove_det_indices.append(det_ind)
-                    to_remove_trk_indices.append(trk_ind)
-                unmatched_dets = np.setdiff1d(unmatched_dets, np.array(to_remove_det_indices))
-                unmatched_trks = np.setdiff1d(unmatched_trks, np.array(to_remove_trk_indices))
-
-        for m in unmatched_trks:
-            self.trackers[m].update(None, None)
-
-        # create and initialise new trackers for unmatched detections
-        for i in unmatched_dets:
-            trk = KalmanBoxTracker(dets[i, :5], dets[i, 5], delta_t=self.delta_t)
-            self.trackers.append(trk)
-        i = len(self.trackers)
-        for trk in reversed(self.trackers):
-            if trk.last_observation.sum() < 0:
-                d = trk.get_state()[0]
-            else:
-                """
-                    this is optional to use the recent observation or the kalman filter prediction,
-                    we didn't notice significant difference here
-                """
-                d = trk.last_observation[:4]
-            if (trk.time_since_update < 1) and (trk.hit_streak >= self.min_hits or self.frame_count <= self.min_hits):
-                # +1 as MOT benchmark requires positive
-                ret.append(np.concatenate((d, [trk.id+1], [trk.cls])).reshape(1, -1))
-            i -= 1
-            # remove dead tracklet
-            if(trk.time_since_update > self.max_age):
-                self.trackers.pop(i)
-        if(len(ret) > 0):
-            return np.concatenate(ret)
-        return np.empty((0, 5))
diff --git a/spaces/xfys/yolov5_tracking/trackers/strong_sort/deep/reid/projects/README.md b/spaces/xfys/yolov5_tracking/trackers/strong_sort/deep/reid/projects/README.md
deleted file mode 100644
index fa63919ffdd31eaa0b7b6bf8032c9c589b4f233d..0000000000000000000000000000000000000000
--- a/spaces/xfys/yolov5_tracking/trackers/strong_sort/deep/reid/projects/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Here are some research projects built on [Torchreid](https://arxiv.org/abs/1910.10093).
-
-+ `OSNet_AIN`: [Learning Generalisable Omni-Scale Representations for Person Re-Identification](https://arxiv.org/abs/1910.06827)
-+ `DML`: [Deep Mutual Learning (CVPR'18)](https://arxiv.org/abs/1706.00384)
-+ `attribute_recognition`: [Omni-Scale Feature Learning for Person Re-Identification (ICCV'19)](https://arxiv.org/abs/1905.00953)
\ No newline at end of file
diff --git a/spaces/xfys/yolov5_tracking/trackers/strong_sort/deep/reid/tools/compute_mean_std.py b/spaces/xfys/yolov5_tracking/trackers/strong_sort/deep/reid/tools/compute_mean_std.py
deleted file mode 100644
index e0a5dbe8dfa746c164b951908fb0b105e4cadbfc..0000000000000000000000000000000000000000
--- a/spaces/xfys/yolov5_tracking/trackers/strong_sort/deep/reid/tools/compute_mean_std.py
+++ /dev/null
@@ -1,59 +0,0 @@
-"""
-Compute channel-wise mean and standard deviation of a dataset.
-
-Usage:
-$ python compute_mean_std.py DATASET_ROOT DATASET_KEY
-
-- The first argument points to the root path where you put the datasets.
-- The second argument means the specific dataset key.
-
-For instance, your datasets are put under $DATA and you wanna
-compute the statistics of Market1501, do
-$ python compute_mean_std.py $DATA market1501
-"""
-import argparse
-
-import torchreid
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument('root', type=str)
-    parser.add_argument('sources', type=str)
-    args = parser.parse_args()
-
-    datamanager = torchreid.data.ImageDataManager(
-        root=args.root,
-        sources=args.sources,
-        targets=None,
-        height=256,
-        width=128,
-        batch_size_train=100,
-        batch_size_test=100,
-        transforms=None,
-        norm_mean=[0., 0., 0.],
-        norm_std=[1., 1., 1.],
-        train_sampler='SequentialSampler'
-    )
-    train_loader = datamanager.train_loader
-
-    print('Computing mean and std ...')
-    mean = 0.
-    std = 0.
-    n_samples = 0.
-    for data in train_loader:
-        data = data['img']
-        batch_size = data.size(0)
-        data = data.view(batch_size, data.size(1), -1)
-        mean += data.mean(2).sum(0)
-        std += data.std(2).sum(0)
-        n_samples += batch_size
-
-    mean /= n_samples
-    std /= n_samples
-    print('Mean: {}'.format(mean))
-    print('Std: {}'.format(std))
-
-
-if __name__ == '__main__':
-    main()
diff --git a/spaces/xfys/yolov5_tracking/trackers/strong_sort/deep/reid/torchreid/models/nasnet.py b/spaces/xfys/yolov5_tracking/trackers/strong_sort/deep/reid/torchreid/models/nasnet.py
deleted file mode 100644
index b1f31def5515c3ba464c86cde471328b50c55b14..0000000000000000000000000000000000000000
--- a/spaces/xfys/yolov5_tracking/trackers/strong_sort/deep/reid/torchreid/models/nasnet.py
+++ /dev/null
@@ -1,1131 +0,0 @@
-from __future__ import division, absolute_import
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.model_zoo as model_zoo
-
-__all__ = ['nasnetamobile']
-"""
-NASNet Mobile
-Thanks to Anastasiia (https://github.com/DagnyT) for the great help, support and motivation!
-
-
-------------------------------------------------------------------------------------
-      Architecture       | Top-1 Acc | Top-5 Acc |  Multiply-Adds |  Params (M)
-------------------------------------------------------------------------------------
-|   NASNet-A (4 @ 1056)  |   74.08%  |   91.74%  |       564 M    |     5.3        |
-------------------------------------------------------------------------------------
-# References:
- - [Learning Transferable Architectures for Scalable Image Recognition]
-    (https://arxiv.org/abs/1707.07012)
-"""
-"""
-Code imported from https://github.com/Cadene/pretrained-models.pytorch
-"""
-
-pretrained_settings = {
-    'nasnetamobile': {
-        'imagenet': {
-            # 'url': 'https://github.com/veronikayurchuk/pretrained-models.pytorch/releases/download/v1.0/nasnetmobile-7e03cead.pth.tar',
-            'url':
-            'http://data.lip6.fr/cadene/pretrainedmodels/nasnetamobile-7e03cead.pth',
-            'input_space': 'RGB',
-            'input_size': [3, 224, 224], # resize 256
-            'input_range': [0, 1],
-            'mean': [0.5, 0.5, 0.5],
-            'std': [0.5, 0.5, 0.5],
-            'num_classes': 1000
-        },
-        # 'imagenet+background': {
-        #     # 'url': 'http://data.lip6.fr/cadene/pretrainedmodels/nasnetalarge-a1897284.pth',
-        #     'input_space': 'RGB',
-        #     'input_size': [3, 224, 224], # resize 256
-        #     'input_range': [0, 1],
-        #     'mean': [0.5, 0.5, 0.5],
-        #     'std': [0.5, 0.5, 0.5],
-        #     'num_classes': 1001
-        # }
-    }
-}
-
-
-class MaxPoolPad(nn.Module):
-
-    def __init__(self):
-        super(MaxPoolPad, self).__init__()
-        self.pad = nn.ZeroPad2d((1, 0, 1, 0))
-        self.pool = nn.MaxPool2d(3, stride=2, padding=1)
-
-    def forward(self, x):
-        x = self.pad(x)
-        x = self.pool(x)
-        x = x[:, :, 1:, 1:].contiguous()
-        return x
-
-
-class AvgPoolPad(nn.Module):
-
-    def __init__(self, stride=2, padding=1):
-        super(AvgPoolPad, self).__init__()
-        self.pad = nn.ZeroPad2d((1, 0, 1, 0))
-        self.pool = nn.AvgPool2d(
-            3, stride=stride, padding=padding, count_include_pad=False
-        )
-
-    def forward(self, x):
-        x = self.pad(x)
-        x = self.pool(x)
-        x = x[:, :, 1:, 1:].contiguous()
-        return x
-
-
-class SeparableConv2d(nn.Module):
-
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        dw_kernel,
-        dw_stride,
-        dw_padding,
-        bias=False
-    ):
-        super(SeparableConv2d, self).__init__()
-        self.depthwise_conv2d = nn.Conv2d(
-            in_channels,
-            in_channels,
-            dw_kernel,
-            stride=dw_stride,
-            padding=dw_padding,
-            bias=bias,
-            groups=in_channels
-        )
-        self.pointwise_conv2d = nn.Conv2d(
-            in_channels, out_channels, 1, stride=1, bias=bias
-        )
-
-    def forward(self, x):
-        x = self.depthwise_conv2d(x)
-        x = self.pointwise_conv2d(x)
-        return x
-
-
-class BranchSeparables(nn.Module):
-
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        kernel_size,
-        stride,
-        padding,
-        name=None,
-        bias=False
-    ):
-        super(BranchSeparables, self).__init__()
-        self.relu = nn.ReLU()
-        self.separable_1 = SeparableConv2d(
-            in_channels, in_channels, kernel_size, stride, padding, bias=bias
-        )
-        self.bn_sep_1 = nn.BatchNorm2d(
-            in_channels, eps=0.001, momentum=0.1, affine=True
-        )
-        self.relu1 = nn.ReLU()
-        self.separable_2 = SeparableConv2d(
-            in_channels, out_channels, kernel_size, 1, padding, bias=bias
-        )
-        self.bn_sep_2 = nn.BatchNorm2d(
-            out_channels, eps=0.001, momentum=0.1, affine=True
-        )
-        self.name = name
-
-    def forward(self, x):
-        x = self.relu(x)
-        if self.name == 'specific':
-            x = nn.ZeroPad2d((1, 0, 1, 0))(x)
-        x = self.separable_1(x)
-        if self.name == 'specific':
-            x = x[:, :, 1:, 1:].contiguous()
-
-        x = self.bn_sep_1(x)
-        x = self.relu1(x)
-        x = self.separable_2(x)
-        x = self.bn_sep_2(x)
-        return x
-
-
-class BranchSeparablesStem(nn.Module):
-
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        kernel_size,
-        stride,
-        padding,
-        bias=False
-    ):
-        super(BranchSeparablesStem, self).__init__()
-        self.relu = nn.ReLU()
-        self.separable_1 = SeparableConv2d(
-            in_channels, out_channels, kernel_size, stride, padding, bias=bias
-        )
-        self.bn_sep_1 = nn.BatchNorm2d(
-            out_channels, eps=0.001, momentum=0.1, affine=True
-        )
-        self.relu1 = nn.ReLU()
-        self.separable_2 = SeparableConv2d(
-            out_channels, out_channels, kernel_size, 1, padding, bias=bias
-        )
-        self.bn_sep_2 = nn.BatchNorm2d(
-            out_channels, eps=0.001, momentum=0.1, affine=True
-        )
-
-    def forward(self, x):
-        x = self.relu(x)
-        x = self.separable_1(x)
-        x = self.bn_sep_1(x)
-        x = self.relu1(x)
-        x = self.separable_2(x)
-        x = self.bn_sep_2(x)
-        return x
-
-
-class BranchSeparablesReduction(BranchSeparables):
-
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        kernel_size,
-        stride,
-        padding,
-        z_padding=1,
-        bias=False
-    ):
-        BranchSeparables.__init__(
-            self, in_channels, out_channels, kernel_size, stride, padding, bias
-        )
-        self.padding = nn.ZeroPad2d((z_padding, 0, z_padding, 0))
-
-    def forward(self, x):
-        x = self.relu(x)
-        x = self.padding(x)
-        x = self.separable_1(x)
-        x = x[:, :, 1:, 1:].contiguous()
-        x = self.bn_sep_1(x)
-        x = self.relu1(x)
-        x = self.separable_2(x)
-        x = self.bn_sep_2(x)
-        return x
-
-
-class CellStem0(nn.Module):
-
-    def __init__(self, stem_filters, num_filters=42):
-        super(CellStem0, self).__init__()
-        self.num_filters = num_filters
-        self.stem_filters = stem_filters
-        self.conv_1x1 = nn.Sequential()
-        self.conv_1x1.add_module('relu', nn.ReLU())
-        self.conv_1x1.add_module(
-            'conv',
-            nn.Conv2d(
-                self.stem_filters, self.num_filters, 1, stride=1, bias=False
-            )
-        )
-        self.conv_1x1.add_module(
-            'bn',
-            nn.BatchNorm2d(
-                self.num_filters, eps=0.001, momentum=0.1, affine=True
-            )
-        )
-
-        self.comb_iter_0_left = BranchSeparables(
-            self.num_filters, self.num_filters, 5, 2, 2
-        )
-        self.comb_iter_0_right = BranchSeparablesStem(
-            self.stem_filters, self.num_filters, 7, 2, 3, bias=False
-        )
-
-        self.comb_iter_1_left = nn.MaxPool2d(3, stride=2, padding=1)
-        self.comb_iter_1_right = BranchSeparablesStem(
-            self.stem_filters, self.num_filters, 7, 2, 3, bias=False
-        )
-
-        self.comb_iter_2_left = nn.AvgPool2d(
-            3, stride=2, padding=1, count_include_pad=False
-        )
-        self.comb_iter_2_right = BranchSeparablesStem(
-            self.stem_filters, self.num_filters, 5, 2, 2, bias=False
-        )
-
-        self.comb_iter_3_right = nn.AvgPool2d(
-            3, stride=1, padding=1, count_include_pad=False
-        )
-
-        self.comb_iter_4_left = BranchSeparables(
-            self.num_filters, self.num_filters, 3, 1, 1, bias=False
-        )
-        self.comb_iter_4_right = nn.MaxPool2d(3, stride=2, padding=1)
-
-    def forward(self, x):
-        x1 = self.conv_1x1(x)
-
-        x_comb_iter_0_left = self.comb_iter_0_left(x1)
-        x_comb_iter_0_right = self.comb_iter_0_right(x)
-        x_comb_iter_0 = x_comb_iter_0_left + x_comb_iter_0_right
-
-        x_comb_iter_1_left = self.comb_iter_1_left(x1)
-        x_comb_iter_1_right = self.comb_iter_1_right(x)
-        x_comb_iter_1 = x_comb_iter_1_left + x_comb_iter_1_right
-
-        x_comb_iter_2_left = self.comb_iter_2_left(x1)
-        x_comb_iter_2_right = self.comb_iter_2_right(x)
-        x_comb_iter_2 = x_comb_iter_2_left + x_comb_iter_2_right
-
-        x_comb_iter_3_right = self.comb_iter_3_right(x_comb_iter_0)
-        x_comb_iter_3 = x_comb_iter_3_right + x_comb_iter_1
-
-        x_comb_iter_4_left = self.comb_iter_4_left(x_comb_iter_0)
-        x_comb_iter_4_right = self.comb_iter_4_right(x1)
-        x_comb_iter_4 = x_comb_iter_4_left + x_comb_iter_4_right
-
-        x_out = torch.cat(
-            [x_comb_iter_1, x_comb_iter_2, x_comb_iter_3, x_comb_iter_4], 1
-        )
-        return x_out
-
-
-class CellStem1(nn.Module):
-
-    def __init__(self, stem_filters, num_filters):
-        super(CellStem1, self).__init__()
-        self.num_filters = num_filters
-        self.stem_filters = stem_filters
-        self.conv_1x1 = nn.Sequential()
-        self.conv_1x1.add_module('relu', nn.ReLU())
-        self.conv_1x1.add_module(
-            'conv',
-            nn.Conv2d(
-                2 * self.num_filters,
-                self.num_filters,
-                1,
-                stride=1,
-                bias=False
-            )
-        )
-        self.conv_1x1.add_module(
-            'bn',
-            nn.BatchNorm2d(
-                self.num_filters, eps=0.001, momentum=0.1, affine=True
-            )
-        )
-
-        self.relu = nn.ReLU()
-        self.path_1 = nn.Sequential()
-        self.path_1.add_module(
-            'avgpool', nn.AvgPool2d(1, stride=2, count_include_pad=False)
-        )
-        self.path_1.add_module(
-            'conv',
-            nn.Conv2d(
-                self.stem_filters,
-                self.num_filters // 2,
-                1,
-                stride=1,
-                bias=False
-            )
-        )
-        self.path_2 = nn.ModuleList()
-        self.path_2.add_module('pad', nn.ZeroPad2d((0, 1, 0, 1)))
-        self.path_2.add_module(
-            'avgpool', nn.AvgPool2d(1, stride=2, count_include_pad=False)
-        )
-        self.path_2.add_module(
-            'conv',
-            nn.Conv2d(
-                self.stem_filters,
-                self.num_filters // 2,
-                1,
-                stride=1,
-                bias=False
-            )
-        )
-
-        self.final_path_bn = nn.BatchNorm2d(
-            self.num_filters, eps=0.001, momentum=0.1, affine=True
-        )
-
-        self.comb_iter_0_left = BranchSeparables(
-            self.num_filters,
-            self.num_filters,
-            5,
-            2,
-            2,
-            name='specific',
-            bias=False
-        )
-        self.comb_iter_0_right = BranchSeparables(
-            self.num_filters,
-            self.num_filters,
-            7,
-            2,
-            3,
-            name='specific',
-            bias=False
-        )
-
-        # self.comb_iter_1_left = nn.MaxPool2d(3, stride=2, padding=1)
-        self.comb_iter_1_left = MaxPoolPad()
-        self.comb_iter_1_right = BranchSeparables(
-            self.num_filters,
-            self.num_filters,
-            7,
-            2,
-            3,
-            name='specific',
-            bias=False
-        )
-
-        # self.comb_iter_2_left = nn.AvgPool2d(3, stride=2, padding=1, count_include_pad=False)
-        self.comb_iter_2_left = AvgPoolPad()
-        self.comb_iter_2_right = BranchSeparables(
-            self.num_filters,
-            self.num_filters,
-            5,
-            2,
-            2,
-            name='specific',
-            bias=False
-        )
-
-        self.comb_iter_3_right = nn.AvgPool2d(
-            3, stride=1, padding=1, count_include_pad=False
-        )
-
-        self.comb_iter_4_left = BranchSeparables(
-            self.num_filters,
-            self.num_filters,
-            3,
-            1,
-            1,
-            name='specific',
-            bias=False
-        )
-        # self.comb_iter_4_right = nn.MaxPool2d(3, stride=2, padding=1)
-        self.comb_iter_4_right = MaxPoolPad()
-
-    def forward(self, x_conv0, x_stem_0):
-        x_left = self.conv_1x1(x_stem_0)
-
-        x_relu = self.relu(x_conv0)
-        # path 1
-        x_path1 = self.path_1(x_relu)
-        # path 2
-        x_path2 = self.path_2.pad(x_relu)
-        x_path2 = x_path2[:, :, 1:, 1:]
-        x_path2 = self.path_2.avgpool(x_path2)
-        x_path2 = self.path_2.conv(x_path2)
-        # final path
-        x_right = self.final_path_bn(torch.cat([x_path1, x_path2], 1))
-
-        x_comb_iter_0_left = self.comb_iter_0_left(x_left)
-        x_comb_iter_0_right = self.comb_iter_0_right(x_right)
-        x_comb_iter_0 = x_comb_iter_0_left + x_comb_iter_0_right
-
-        x_comb_iter_1_left = self.comb_iter_1_left(x_left)
-        x_comb_iter_1_right = self.comb_iter_1_right(x_right)
-        x_comb_iter_1 = x_comb_iter_1_left + x_comb_iter_1_right
-
-        x_comb_iter_2_left = self.comb_iter_2_left(x_left)
-        x_comb_iter_2_right = self.comb_iter_2_right(x_right)
-        x_comb_iter_2 = x_comb_iter_2_left + x_comb_iter_2_right
-
-        x_comb_iter_3_right = self.comb_iter_3_right(x_comb_iter_0)
-        x_comb_iter_3 = x_comb_iter_3_right + x_comb_iter_1
-
-        x_comb_iter_4_left = self.comb_iter_4_left(x_comb_iter_0)
-        x_comb_iter_4_right = self.comb_iter_4_right(x_left)
-        x_comb_iter_4 = x_comb_iter_4_left + x_comb_iter_4_right
-
-        x_out = torch.cat(
-            [x_comb_iter_1, x_comb_iter_2, x_comb_iter_3, x_comb_iter_4], 1
-        )
-        return x_out
-
-
-class FirstCell(nn.Module):
-
-    def __init__(
-        self, in_channels_left, out_channels_left, in_channels_right,
-        out_channels_right
-    ):
-        super(FirstCell, self).__init__()
-        self.conv_1x1 = nn.Sequential()
-        self.conv_1x1.add_module('relu', nn.ReLU())
-        self.conv_1x1.add_module(
-            'conv',
-            nn.Conv2d(
-                in_channels_right, out_channels_right, 1, stride=1, bias=False
-            )
-        )
-        self.conv_1x1.add_module(
-            'bn',
-            nn.BatchNorm2d(
-                out_channels_right, eps=0.001, momentum=0.1, affine=True
-            )
-        )
-
-        self.relu = nn.ReLU()
-        self.path_1 = nn.Sequential()
-        self.path_1.add_module(
-            'avgpool', nn.AvgPool2d(1, stride=2, count_include_pad=False)
-        )
-        self.path_1.add_module(
-            'conv',
-            nn.Conv2d(
-                in_channels_left, out_channels_left, 1, stride=1, bias=False
-            )
-        )
-        self.path_2 = nn.ModuleList()
-        self.path_2.add_module('pad', nn.ZeroPad2d((0, 1, 0, 1)))
-        self.path_2.add_module(
-            'avgpool', nn.AvgPool2d(1, stride=2, count_include_pad=False)
-        )
-        self.path_2.add_module(
-            'conv',
-            nn.Conv2d(
-                in_channels_left, out_channels_left, 1, stride=1, bias=False
-            )
-        )
-
-        self.final_path_bn = nn.BatchNorm2d(
-            out_channels_left * 2, eps=0.001, momentum=0.1, affine=True
-        )
-
-        self.comb_iter_0_left = BranchSeparables(
-            out_channels_right, out_channels_right, 5, 1, 2, bias=False
-        )
-        self.comb_iter_0_right = BranchSeparables(
-            out_channels_right, out_channels_right, 3, 1, 1, bias=False
-        )
-
-        self.comb_iter_1_left = BranchSeparables(
-            out_channels_right, out_channels_right, 5, 1, 2, bias=False
-        )
-        self.comb_iter_1_right = BranchSeparables(
-            out_channels_right, out_channels_right, 3, 1, 1, bias=False
-        )
-
-        self.comb_iter_2_left = nn.AvgPool2d(
-            3, stride=1, padding=1, count_include_pad=False
-        )
-
-        self.comb_iter_3_left = nn.AvgPool2d(
-            3, stride=1, padding=1, count_include_pad=False
-        )
-        self.comb_iter_3_right = nn.AvgPool2d(
-            3, stride=1, padding=1, count_include_pad=False
-        )
-
-        self.comb_iter_4_left = BranchSeparables(
-            out_channels_right, out_channels_right, 3, 1, 1, bias=False
-        )
-
-    def forward(self, x, x_prev):
-        x_relu = self.relu(x_prev)
-        # path 1
-        x_path1 = self.path_1(x_relu)
-        # path 2
-        x_path2 = self.path_2.pad(x_relu)
-        x_path2 = x_path2[:, :, 1:, 1:]
-        x_path2 = self.path_2.avgpool(x_path2)
-        x_path2 = self.path_2.conv(x_path2)
-        # final path
-        x_left = self.final_path_bn(torch.cat([x_path1, x_path2], 1))
-
-        x_right = self.conv_1x1(x)
-
-        x_comb_iter_0_left = self.comb_iter_0_left(x_right)
-        x_comb_iter_0_right = self.comb_iter_0_right(x_left)
-        x_comb_iter_0 = x_comb_iter_0_left + x_comb_iter_0_right
-
-        x_comb_iter_1_left = self.comb_iter_1_left(x_left)
-        x_comb_iter_1_right = self.comb_iter_1_right(x_left)
-        x_comb_iter_1 = x_comb_iter_1_left + x_comb_iter_1_right
-
-        x_comb_iter_2_left = self.comb_iter_2_left(x_right)
-        x_comb_iter_2 = x_comb_iter_2_left + x_left
-
-        x_comb_iter_3_left = self.comb_iter_3_left(x_left)
-        x_comb_iter_3_right = self.comb_iter_3_right(x_left)
-        x_comb_iter_3 = x_comb_iter_3_left + x_comb_iter_3_right
-
-        x_comb_iter_4_left = self.comb_iter_4_left(x_right)
-        x_comb_iter_4 = x_comb_iter_4_left + x_right
-
-        x_out = torch.cat(
-            [
-                x_left, x_comb_iter_0, x_comb_iter_1, x_comb_iter_2,
-                x_comb_iter_3, x_comb_iter_4
-            ], 1
-        )
-        return x_out
-
-
-class NormalCell(nn.Module):
-
-    def __init__(
-        self, in_channels_left, out_channels_left, in_channels_right,
-        out_channels_right
-    ):
-        super(NormalCell, self).__init__()
-        self.conv_prev_1x1 = nn.Sequential()
-        self.conv_prev_1x1.add_module('relu', nn.ReLU())
-        self.conv_prev_1x1.add_module(
-            'conv',
-            nn.Conv2d(
-                in_channels_left, out_channels_left, 1, stride=1, bias=False
-            )
-        )
-        self.conv_prev_1x1.add_module(
-            'bn',
-            nn.BatchNorm2d(
-                out_channels_left, eps=0.001, momentum=0.1, affine=True
-            )
-        )
-
-        self.conv_1x1 = nn.Sequential()
-        self.conv_1x1.add_module('relu', nn.ReLU())
-        self.conv_1x1.add_module(
-            'conv',
-            nn.Conv2d(
-                in_channels_right, out_channels_right, 1, stride=1, bias=False
-            )
-        )
-        self.conv_1x1.add_module(
-            'bn',
-            nn.BatchNorm2d(
-                out_channels_right, eps=0.001, momentum=0.1, affine=True
-            )
-        )
-
-        self.comb_iter_0_left = BranchSeparables(
-            out_channels_right, out_channels_right, 5, 1, 2, bias=False
-        )
-        self.comb_iter_0_right = BranchSeparables(
-            out_channels_left, out_channels_left, 3, 1, 1, bias=False
-        )
-
-        self.comb_iter_1_left = BranchSeparables(
-            out_channels_left, out_channels_left, 5, 1, 2, bias=False
-        )
-        self.comb_iter_1_right = BranchSeparables(
-            out_channels_left, out_channels_left, 3, 1, 1, bias=False
-        )
-
-        self.comb_iter_2_left = nn.AvgPool2d(
-            3, stride=1, padding=1, count_include_pad=False
-        )
-
-        self.comb_iter_3_left = nn.AvgPool2d(
-            3, stride=1, padding=1, count_include_pad=False
-        )
-        self.comb_iter_3_right = nn.AvgPool2d(
-            3, stride=1, padding=1, count_include_pad=False
-        )
-
-        self.comb_iter_4_left = BranchSeparables(
-            out_channels_right, out_channels_right, 3, 1, 1, bias=False
-        )
-
-    def forward(self, x, x_prev):
-        x_left = self.conv_prev_1x1(x_prev)
-        x_right = self.conv_1x1(x)
-
-        x_comb_iter_0_left = self.comb_iter_0_left(x_right)
-        x_comb_iter_0_right = self.comb_iter_0_right(x_left)
-        x_comb_iter_0 = x_comb_iter_0_left + x_comb_iter_0_right
-
-        x_comb_iter_1_left = self.comb_iter_1_left(x_left)
-        x_comb_iter_1_right = self.comb_iter_1_right(x_left)
-        x_comb_iter_1 = x_comb_iter_1_left + x_comb_iter_1_right
-
-        x_comb_iter_2_left = self.comb_iter_2_left(x_right)
-        x_comb_iter_2 = x_comb_iter_2_left + x_left
-
-        x_comb_iter_3_left = self.comb_iter_3_left(x_left)
-        x_comb_iter_3_right = self.comb_iter_3_right(x_left)
-        x_comb_iter_3 = x_comb_iter_3_left + x_comb_iter_3_right
-
-        x_comb_iter_4_left = self.comb_iter_4_left(x_right)
-        x_comb_iter_4 = x_comb_iter_4_left + x_right
-
-        x_out = torch.cat(
-            [
-                x_left, x_comb_iter_0, x_comb_iter_1, x_comb_iter_2,
-                x_comb_iter_3, x_comb_iter_4
-            ], 1
-        )
-        return x_out
-
-
-class ReductionCell0(nn.Module):
-
-    def __init__(
-        self, in_channels_left, out_channels_left, in_channels_right,
-        out_channels_right
-    ):
-        super(ReductionCell0, self).__init__()
-        self.conv_prev_1x1 = nn.Sequential()
-        self.conv_prev_1x1.add_module('relu', nn.ReLU())
-        self.conv_prev_1x1.add_module(
-            'conv',
-            nn.Conv2d(
-                in_channels_left, out_channels_left, 1, stride=1, bias=False
-            )
-        )
-        self.conv_prev_1x1.add_module(
-            'bn',
-            nn.BatchNorm2d(
-                out_channels_left, eps=0.001, momentum=0.1, affine=True
-            )
-        )
-
-        self.conv_1x1 = nn.Sequential()
-        self.conv_1x1.add_module('relu', nn.ReLU())
-        self.conv_1x1.add_module(
-            'conv',
-            nn.Conv2d(
-                in_channels_right, out_channels_right, 1, stride=1, bias=False
-            )
-        )
-        self.conv_1x1.add_module(
-            'bn',
-            nn.BatchNorm2d(
-                out_channels_right, eps=0.001, momentum=0.1, affine=True
-            )
-        )
-
-        self.comb_iter_0_left = BranchSeparablesReduction(
-            out_channels_right, out_channels_right, 5, 2, 2, bias=False
-        )
-        self.comb_iter_0_right = BranchSeparablesReduction(
-            out_channels_right, out_channels_right, 7, 2, 3, bias=False
-        )
-
-        self.comb_iter_1_left = MaxPoolPad()
-        self.comb_iter_1_right = BranchSeparablesReduction(
-            out_channels_right, out_channels_right, 7, 2, 3, bias=False
-        )
-
-        self.comb_iter_2_left = AvgPoolPad()
-        self.comb_iter_2_right = BranchSeparablesReduction(
-            out_channels_right, out_channels_right, 5, 2, 2, bias=False
-        )
-
-        self.comb_iter_3_right = nn.AvgPool2d(
-            3, stride=1, padding=1, count_include_pad=False
-        )
-
-        self.comb_iter_4_left = BranchSeparablesReduction(
-            out_channels_right, out_channels_right, 3, 1, 1, bias=False
-        )
-        self.comb_iter_4_right = MaxPoolPad()
-
-    def forward(self, x, x_prev):
-        x_left = self.conv_prev_1x1(x_prev)
-        x_right = self.conv_1x1(x)
-
-        x_comb_iter_0_left = self.comb_iter_0_left(x_right)
-        x_comb_iter_0_right = self.comb_iter_0_right(x_left)
-        x_comb_iter_0 = x_comb_iter_0_left + x_comb_iter_0_right
-
-        x_comb_iter_1_left = self.comb_iter_1_left(x_right)
-        x_comb_iter_1_right = self.comb_iter_1_right(x_left)
-        x_comb_iter_1 = x_comb_iter_1_left + x_comb_iter_1_right
-
-        x_comb_iter_2_left = self.comb_iter_2_left(x_right)
-        x_comb_iter_2_right = self.comb_iter_2_right(x_left)
-        x_comb_iter_2 = x_comb_iter_2_left + x_comb_iter_2_right
-
-        x_comb_iter_3_right = self.comb_iter_3_right(x_comb_iter_0)
-        x_comb_iter_3 = x_comb_iter_3_right + x_comb_iter_1
-
-        x_comb_iter_4_left = self.comb_iter_4_left(x_comb_iter_0)
-        x_comb_iter_4_right = self.comb_iter_4_right(x_right)
-        x_comb_iter_4 = x_comb_iter_4_left + x_comb_iter_4_right
-
-        x_out = torch.cat(
-            [x_comb_iter_1, x_comb_iter_2, x_comb_iter_3, x_comb_iter_4], 1
-        )
-        return x_out
-
-
-class ReductionCell1(nn.Module):
-
-    def __init__(
-        self, in_channels_left, out_channels_left, in_channels_right,
-        out_channels_right
-    ):
-        super(ReductionCell1, self).__init__()
-        self.conv_prev_1x1 = nn.Sequential()
-        self.conv_prev_1x1.add_module('relu', nn.ReLU())
-        self.conv_prev_1x1.add_module(
-            'conv',
-            nn.Conv2d(
-                in_channels_left, out_channels_left, 1, stride=1, bias=False
-            )
-        )
-        self.conv_prev_1x1.add_module(
-            'bn',
-            nn.BatchNorm2d(
-                out_channels_left, eps=0.001, momentum=0.1, affine=True
-            )
-        )
-
-        self.conv_1x1 = nn.Sequential()
-        self.conv_1x1.add_module('relu', nn.ReLU())
-        self.conv_1x1.add_module(
-            'conv',
-            nn.Conv2d(
-                in_channels_right, out_channels_right, 1, stride=1, bias=False
-            )
-        )
-        self.conv_1x1.add_module(
-            'bn',
-            nn.BatchNorm2d(
-                out_channels_right, eps=0.001, momentum=0.1, affine=True
-            )
-        )
-
-        self.comb_iter_0_left = BranchSeparables(
-            out_channels_right,
-            out_channels_right,
-            5,
-            2,
-            2,
-            name='specific',
-            bias=False
-        )
-        self.comb_iter_0_right = BranchSeparables(
-            out_channels_right,
-            out_channels_right,
-            7,
-            2,
-            3,
-            name='specific',
-            bias=False
-        )
-
-        # self.comb_iter_1_left = nn.MaxPool2d(3, stride=2, padding=1)
-        self.comb_iter_1_left = MaxPoolPad()
-        self.comb_iter_1_right = BranchSeparables(
-            out_channels_right,
-            out_channels_right,
-            7,
-            2,
-            3,
-            name='specific',
-            bias=False
-        )
-
-        # self.comb_iter_2_left = nn.AvgPool2d(3, stride=2, padding=1, count_include_pad=False)
-        self.comb_iter_2_left = AvgPoolPad()
-        self.comb_iter_2_right = BranchSeparables(
-            out_channels_right,
-            out_channels_right,
-            5,
-            2,
-            2,
-            name='specific',
-            bias=False
-        )
-
-        self.comb_iter_3_right = nn.AvgPool2d(
-            3, stride=1, padding=1, count_include_pad=False
-        )
-
-        self.comb_iter_4_left = BranchSeparables(
-            out_channels_right,
-            out_channels_right,
-            3,
-            1,
-            1,
-            name='specific',
-            bias=False
-        )
-        # self.comb_iter_4_right = nn.MaxPool2d(3, stride=2, padding=1)
-        self.comb_iter_4_right = MaxPoolPad()
-
-    def forward(self, x, x_prev):
-        x_left = self.conv_prev_1x1(x_prev)
-        x_right = self.conv_1x1(x)
-
-        x_comb_iter_0_left = self.comb_iter_0_left(x_right)
-        x_comb_iter_0_right = self.comb_iter_0_right(x_left)
-        x_comb_iter_0 = x_comb_iter_0_left + x_comb_iter_0_right
-
-        x_comb_iter_1_left = self.comb_iter_1_left(x_right)
-        x_comb_iter_1_right = self.comb_iter_1_right(x_left)
-        x_comb_iter_1 = x_comb_iter_1_left + x_comb_iter_1_right
-
-        x_comb_iter_2_left = self.comb_iter_2_left(x_right)
-        x_comb_iter_2_right = self.comb_iter_2_right(x_left)
-        x_comb_iter_2 = x_comb_iter_2_left + x_comb_iter_2_right
-
-        x_comb_iter_3_right = self.comb_iter_3_right(x_comb_iter_0)
-        x_comb_iter_3 = x_comb_iter_3_right + x_comb_iter_1
-
-        x_comb_iter_4_left = self.comb_iter_4_left(x_comb_iter_0)
-        x_comb_iter_4_right = self.comb_iter_4_right(x_right)
-        x_comb_iter_4 = x_comb_iter_4_left + x_comb_iter_4_right
-
-        x_out = torch.cat(
-            [x_comb_iter_1, x_comb_iter_2, x_comb_iter_3, x_comb_iter_4], 1
-        )
-        return x_out
-
-
-class NASNetAMobile(nn.Module):
-    """Neural Architecture Search (NAS).
-
-    Reference:
-        Zoph et al. Learning Transferable Architectures
-        for Scalable Image Recognition. CVPR 2018.
-
-    Public keys:
-        - ``nasnetamobile``: NASNet-A Mobile.
-    """
-
-    def __init__(
-        self,
-        num_classes,
-        loss,
-        stem_filters=32,
-        penultimate_filters=1056,
-        filters_multiplier=2,
-        **kwargs
-    ):
-        super(NASNetAMobile, self).__init__()
-        self.stem_filters = stem_filters
-        self.penultimate_filters = penultimate_filters
-        self.filters_multiplier = filters_multiplier
-        self.loss = loss
-
-        filters = self.penultimate_filters // 24
-        # 24 is default value for the architecture
-
-        self.conv0 = nn.Sequential()
-        self.conv0.add_module(
-            'conv',
-            nn.Conv2d(
-                in_channels=3,
-                out_channels=self.stem_filters,
-                kernel_size=3,
-                padding=0,
-                stride=2,
-                bias=False
-            )
-        )
-        self.conv0.add_module(
-            'bn',
-            nn.BatchNorm2d(
-                self.stem_filters, eps=0.001, momentum=0.1, affine=True
-            )
-        )
-
-        self.cell_stem_0 = CellStem0(
-            self.stem_filters, num_filters=filters // (filters_multiplier**2)
-        )
-        self.cell_stem_1 = CellStem1(
-            self.stem_filters, num_filters=filters // filters_multiplier
-        )
-
-        self.cell_0 = FirstCell(
-            in_channels_left=filters,
-            out_channels_left=filters // 2, # 1, 0.5
-            in_channels_right=2 * filters,
-            out_channels_right=filters
-        ) # 2, 1
-        self.cell_1 = NormalCell(
-            in_channels_left=2 * filters,
-            out_channels_left=filters, # 2, 1
-            in_channels_right=6 * filters,
-            out_channels_right=filters
-        ) # 6, 1
-        self.cell_2 = NormalCell(
-            in_channels_left=6 * filters,
-            out_channels_left=filters, # 6, 1
-            in_channels_right=6 * filters,
-            out_channels_right=filters
-        ) # 6, 1
-        self.cell_3 = NormalCell(
-            in_channels_left=6 * filters,
-            out_channels_left=filters, # 6, 1
-            in_channels_right=6 * filters,
-            out_channels_right=filters
-        ) # 6, 1
-
-        self.reduction_cell_0 = ReductionCell0(
-            in_channels_left=6 * filters,
-            out_channels_left=2 * filters, # 6, 2
-            in_channels_right=6 * filters,
-            out_channels_right=2 * filters
-        ) # 6, 2
-
-        self.cell_6 = FirstCell(
-            in_channels_left=6 * filters,
-            out_channels_left=filters, # 6, 1
-            in_channels_right=8 * filters,
-            out_channels_right=2 * filters
-        ) # 8, 2
-        self.cell_7 = NormalCell(
-            in_channels_left=8 * filters,
-            out_channels_left=2 * filters, # 8, 2
-            in_channels_right=12 * filters,
-            out_channels_right=2 * filters
-        ) # 12, 2
-        self.cell_8 = NormalCell(
-            in_channels_left=12 * filters,
-            out_channels_left=2 * filters, # 12, 2
-            in_channels_right=12 * filters,
-            out_channels_right=2 * filters
-        ) # 12, 2
-        self.cell_9 = NormalCell(
-            in_channels_left=12 * filters,
-            out_channels_left=2 * filters, # 12, 2
-            in_channels_right=12 * filters,
-            out_channels_right=2 * filters
-        ) # 12, 2
-
-        self.reduction_cell_1 = ReductionCell1(
-            in_channels_left=12 * filters,
-            out_channels_left=4 * filters, # 12, 4
-            in_channels_right=12 * filters,
-            out_channels_right=4 * filters
-        ) # 12, 4
-
-        self.cell_12 = FirstCell(
-            in_channels_left=12 * filters,
-            out_channels_left=2 * filters, # 12, 2
-            in_channels_right=16 * filters,
-            out_channels_right=4 * filters
-        ) # 16, 4
-        self.cell_13 = NormalCell(
-            in_channels_left=16 * filters,
-            out_channels_left=4 * filters, # 16, 4
-            in_channels_right=24 * filters,
-            out_channels_right=4 * filters
-        ) # 24, 4
-        self.cell_14 = NormalCell(
-            in_channels_left=24 * filters,
-            out_channels_left=4 * filters, # 24, 4
-            in_channels_right=24 * filters,
-            out_channels_right=4 * filters
-        ) # 24, 4
-        self.cell_15 = NormalCell(
-            in_channels_left=24 * filters,
-            out_channels_left=4 * filters, # 24, 4
-            in_channels_right=24 * filters,
-            out_channels_right=4 * filters
-        ) # 24, 4
-
-        self.relu = nn.ReLU()
-        self.dropout = nn.Dropout()
-        self.classifier = nn.Linear(24 * filters, num_classes)
-
-        self._init_params()
-
-    def _init_params(self):
-        for m in self.modules():
-            if isinstance(m, nn.Conv2d):
-                nn.init.kaiming_normal_(
-                    m.weight, mode='fan_out', nonlinearity='relu'
-                )
-                if m.bias is not None:
-                    nn.init.constant_(m.bias, 0)
-            elif isinstance(m, nn.BatchNorm2d):
-                nn.init.constant_(m.weight, 1)
-                nn.init.constant_(m.bias, 0)
-            elif isinstance(m, nn.BatchNorm1d):
-                nn.init.constant_(m.weight, 1)
-                nn.init.constant_(m.bias, 0)
-            elif isinstance(m, nn.Linear):
-                nn.init.normal_(m.weight, 0, 0.01)
-                if m.bias is not None:
-                    nn.init.constant_(m.bias, 0)
-
-    def features(self, input):
-        x_conv0 = self.conv0(input)
-        x_stem_0 = self.cell_stem_0(x_conv0)
-        x_stem_1 = self.cell_stem_1(x_conv0, x_stem_0)
-
-        x_cell_0 = self.cell_0(x_stem_1, x_stem_0)
-        x_cell_1 = self.cell_1(x_cell_0, x_stem_1)
-        x_cell_2 = self.cell_2(x_cell_1, x_cell_0)
-        x_cell_3 = self.cell_3(x_cell_2, x_cell_1)
-
-        x_reduction_cell_0 = self.reduction_cell_0(x_cell_3, x_cell_2)
-
-        x_cell_6 = self.cell_6(x_reduction_cell_0, x_cell_3)
-        x_cell_7 = self.cell_7(x_cell_6, x_reduction_cell_0)
-        x_cell_8 = self.cell_8(x_cell_7, x_cell_6)
-        x_cell_9 = self.cell_9(x_cell_8, x_cell_7)
-
-        x_reduction_cell_1 = self.reduction_cell_1(x_cell_9, x_cell_8)
-
-        x_cell_12 = self.cell_12(x_reduction_cell_1, x_cell_9)
-        x_cell_13 = self.cell_13(x_cell_12, x_reduction_cell_1)
-        x_cell_14 = self.cell_14(x_cell_13, x_cell_12)
-        x_cell_15 = self.cell_15(x_cell_14, x_cell_13)
-
-        x_cell_15 = self.relu(x_cell_15)
-        x_cell_15 = F.avg_pool2d(
-            x_cell_15,
-            x_cell_15.size()[2:]
-        ) # global average pool
-        x_cell_15 = x_cell_15.view(x_cell_15.size(0), -1)
-        x_cell_15 = self.dropout(x_cell_15)
-
-        return x_cell_15
-
-    def forward(self, input):
-        v = self.features(input)
-
-        if not self.training:
-            return v
-
-        y = self.classifier(v)
-
-        if self.loss == 'softmax':
-            return y
-        elif self.loss == 'triplet':
-            return y, v
-        else:
-            raise KeyError('Unsupported loss: {}'.format(self.loss))
-
-
-def init_pretrained_weights(model, model_url):
-    """Initializes model with pretrained weights.
-    
-    Layers that don't match with pretrained layers in name or size are kept unchanged.
-    """
-    pretrain_dict = model_zoo.load_url(model_url)
-    model_dict = model.state_dict()
-    pretrain_dict = {
-        k: v
-        for k, v in pretrain_dict.items()
-        if k in model_dict and model_dict[k].size() == v.size()
-    }
-    model_dict.update(pretrain_dict)
-    model.load_state_dict(model_dict)
-
-
-def nasnetamobile(num_classes, loss='softmax', pretrained=True, **kwargs):
-    model = NASNetAMobile(num_classes, loss, **kwargs)
-    if pretrained:
-        model_url = pretrained_settings['nasnetamobile']['imagenet']['url']
-        init_pretrained_weights(model, model_url)
-    return model
diff --git a/spaces/xiang-wuu/yolov5/train.py b/spaces/xiang-wuu/yolov5/train.py
deleted file mode 100644
index c298692b7335ed03deca8e47624b5b69127230e2..0000000000000000000000000000000000000000
--- a/spaces/xiang-wuu/yolov5/train.py
+++ /dev/null
@@ -1,642 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Train a YOLOv5 model on a custom dataset.
-
-Models and datasets download automatically from the latest YOLOv5 release.
-Models: https://github.com/ultralytics/yolov5/tree/master/models
-Datasets: https://github.com/ultralytics/yolov5/tree/master/data
-Tutorial: https://github.com/ultralytics/yolov5/wiki/Train-Custom-Data
-
-Usage:
-    $ python path/to/train.py --data coco128.yaml --weights yolov5s.pt --img 640  # from pretrained (RECOMMENDED)
-    $ python path/to/train.py --data coco128.yaml --weights '' --cfg yolov5s.yaml --img 640  # from scratch
-"""
-
-import argparse
-import math
-import os
-import random
-import sys
-import time
-from copy import deepcopy
-from datetime import datetime
-from pathlib import Path
-
-import numpy as np
-import torch
-import torch.distributed as dist
-import torch.nn as nn
-import yaml
-from torch.optim import lr_scheduler
-from tqdm import tqdm
-
-FILE = Path(__file__).resolve()
-ROOT = FILE.parents[0]  # YOLOv5 root directory
-if str(ROOT) not in sys.path:
-    sys.path.append(str(ROOT))  # add ROOT to PATH
-ROOT = Path(os.path.relpath(ROOT, Path.cwd()))  # relative
-
-import val  # for end-of-epoch mAP
-from models.experimental import attempt_load
-from models.yolo import Model
-from utils.autoanchor import check_anchors
-from utils.autobatch import check_train_batch_size
-from utils.callbacks import Callbacks
-from utils.dataloaders import create_dataloader
-from utils.downloads import attempt_download
-from utils.general import (LOGGER, check_amp, check_dataset, check_file, check_git_status, check_img_size,
-                           check_requirements, check_suffix, check_yaml, colorstr, get_latest_run, increment_path,
-                           init_seeds, intersect_dicts, labels_to_class_weights, labels_to_image_weights, methods,
-                           one_cycle, print_args, print_mutation, strip_optimizer)
-from utils.loggers import Loggers
-from utils.loggers.wandb.wandb_utils import check_wandb_resume
-from utils.loss import ComputeLoss
-from utils.metrics import fitness
-from utils.plots import plot_evolve, plot_labels
-from utils.torch_utils import (EarlyStopping, ModelEMA, de_parallel, select_device, smart_DDP, smart_optimizer,
-                               torch_distributed_zero_first)
-
-LOCAL_RANK = int(os.getenv('LOCAL_RANK', -1))  # https://pytorch.org/docs/stable/elastic/run.html
-RANK = int(os.getenv('RANK', -1))
-WORLD_SIZE = int(os.getenv('WORLD_SIZE', 1))
-
-
-def train(hyp, opt, device, callbacks):  # hyp is path/to/hyp.yaml or hyp dictionary
-    save_dir, epochs, batch_size, weights, single_cls, evolve, data, cfg, resume, noval, nosave, workers, freeze = \
-        Path(opt.save_dir), opt.epochs, opt.batch_size, opt.weights, opt.single_cls, opt.evolve, opt.data, opt.cfg, \
-        opt.resume, opt.noval, opt.nosave, opt.workers, opt.freeze
-    callbacks.run('on_pretrain_routine_start')
-
-    # Directories
-    w = save_dir / 'weights'  # weights dir
-    (w.parent if evolve else w).mkdir(parents=True, exist_ok=True)  # make dir
-    last, best = w / 'last.pt', w / 'best.pt'
-
-    # Hyperparameters
-    if isinstance(hyp, str):
-        with open(hyp, errors='ignore') as f:
-            hyp = yaml.safe_load(f)  # load hyps dict
-    LOGGER.info(colorstr('hyperparameters: ') + ', '.join(f'{k}={v}' for k, v in hyp.items()))
-
-    # Save run settings
-    if not evolve:
-        with open(save_dir / 'hyp.yaml', 'w') as f:
-            yaml.safe_dump(hyp, f, sort_keys=False)
-        with open(save_dir / 'opt.yaml', 'w') as f:
-            yaml.safe_dump(vars(opt), f, sort_keys=False)
-
-    # Loggers
-    data_dict = None
-    if RANK in {-1, 0}:
-        loggers = Loggers(save_dir, weights, opt, hyp, LOGGER)  # loggers instance
-        if loggers.wandb:
-            data_dict = loggers.wandb.data_dict
-            if resume:
-                weights, epochs, hyp, batch_size = opt.weights, opt.epochs, opt.hyp, opt.batch_size
-
-        # Register actions
-        for k in methods(loggers):
-            callbacks.register_action(k, callback=getattr(loggers, k))
-
-    # Config
-    plots = not evolve and not opt.noplots  # create plots
-    cuda = device.type != 'cpu'
-    init_seeds(opt.seed + 1 + RANK, deterministic=True)
-    with torch_distributed_zero_first(LOCAL_RANK):
-        data_dict = data_dict or check_dataset(data)  # check if None
-    train_path, val_path = data_dict['train'], data_dict['val']
-    nc = 1 if single_cls else int(data_dict['nc'])  # number of classes
-    names = ['item'] if single_cls and len(data_dict['names']) != 1 else data_dict['names']  # class names
-    assert len(names) == nc, f'{len(names)} names found for nc={nc} dataset in {data}'  # check
-    is_coco = isinstance(val_path, str) and val_path.endswith('coco/val2017.txt')  # COCO dataset
-
-    # Model
-    check_suffix(weights, '.pt')  # check weights
-    pretrained = weights.endswith('.pt')
-    if pretrained:
-        with torch_distributed_zero_first(LOCAL_RANK):
-            weights = attempt_download(weights)  # download if not found locally
-        ckpt = torch.load(weights, map_location='cpu')  # load checkpoint to CPU to avoid CUDA memory leak
-        model = Model(cfg or ckpt['model'].yaml, ch=3, nc=nc, anchors=hyp.get('anchors')).to(device)  # create
-        exclude = ['anchor'] if (cfg or hyp.get('anchors')) and not resume else []  # exclude keys
-        csd = ckpt['model'].float().state_dict()  # checkpoint state_dict as FP32
-        csd = intersect_dicts(csd, model.state_dict(), exclude=exclude)  # intersect
-        model.load_state_dict(csd, strict=False)  # load
-        LOGGER.info(f'Transferred {len(csd)}/{len(model.state_dict())} items from {weights}')  # report
-    else:
-        model = Model(cfg, ch=3, nc=nc, anchors=hyp.get('anchors')).to(device)  # create
-    amp = check_amp(model)  # check AMP
-
-    # Freeze
-    freeze = [f'model.{x}.' for x in (freeze if len(freeze) > 1 else range(freeze[0]))]  # layers to freeze
-    for k, v in model.named_parameters():
-        v.requires_grad = True  # train all layers
-        if any(x in k for x in freeze):
-            LOGGER.info(f'freezing {k}')
-            v.requires_grad = False
-
-    # Image size
-    gs = max(int(model.stride.max()), 32)  # grid size (max stride)
-    imgsz = check_img_size(opt.imgsz, gs, floor=gs * 2)  # verify imgsz is gs-multiple
-
-    # Batch size
-    if RANK == -1 and batch_size == -1:  # single-GPU only, estimate best batch size
-        batch_size = check_train_batch_size(model, imgsz, amp)
-        loggers.on_params_update({"batch_size": batch_size})
-
-    # Optimizer
-    nbs = 64  # nominal batch size
-    accumulate = max(round(nbs / batch_size), 1)  # accumulate loss before optimizing
-    hyp['weight_decay'] *= batch_size * accumulate / nbs  # scale weight_decay
-    LOGGER.info(f"Scaled weight_decay = {hyp['weight_decay']}")
-    optimizer = smart_optimizer(model, opt.optimizer, hyp['lr0'], hyp['momentum'], hyp['weight_decay'])
-
-    # Scheduler
-    if opt.cos_lr:
-        lf = one_cycle(1, hyp['lrf'], epochs)  # cosine 1->hyp['lrf']
-    else:
-        lf = lambda x: (1 - x / epochs) * (1.0 - hyp['lrf']) + hyp['lrf']  # linear
-    scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lf)  # plot_lr_scheduler(optimizer, scheduler, epochs)
-
-    # EMA
-    ema = ModelEMA(model) if RANK in {-1, 0} else None
-
-    # Resume
-    start_epoch, best_fitness = 0, 0.0
-    if pretrained:
-        # Optimizer
-        if ckpt['optimizer'] is not None:
-            optimizer.load_state_dict(ckpt['optimizer'])
-            best_fitness = ckpt['best_fitness']
-
-        # EMA
-        if ema and ckpt.get('ema'):
-            ema.ema.load_state_dict(ckpt['ema'].float().state_dict())
-            ema.updates = ckpt['updates']
-
-        # Epochs
-        start_epoch = ckpt['epoch'] + 1
-        if resume:
-            assert start_epoch > 0, f'{weights} training to {epochs} epochs is finished, nothing to resume.'
-        if epochs < start_epoch:
-            LOGGER.info(f"{weights} has been trained for {ckpt['epoch']} epochs. Fine-tuning for {epochs} more epochs.")
-            epochs += ckpt['epoch']  # finetune additional epochs
-
-        del ckpt, csd
-
-    # DP mode
-    if cuda and RANK == -1 and torch.cuda.device_count() > 1:
-        LOGGER.warning('WARNING: DP not recommended, use torch.distributed.run for best DDP Multi-GPU results.\n'
-                       'See Multi-GPU Tutorial at https://github.com/ultralytics/yolov5/issues/475 to get started.')
-        model = torch.nn.DataParallel(model)
-
-    # SyncBatchNorm
-    if opt.sync_bn and cuda and RANK != -1:
-        model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model).to(device)
-        LOGGER.info('Using SyncBatchNorm()')
-
-    # Trainloader
-    train_loader, dataset = create_dataloader(train_path,
-                                              imgsz,
-                                              batch_size // WORLD_SIZE,
-                                              gs,
-                                              single_cls,
-                                              hyp=hyp,
-                                              augment=True,
-                                              cache=None if opt.cache == 'val' else opt.cache,
-                                              rect=opt.rect,
-                                              rank=LOCAL_RANK,
-                                              workers=workers,
-                                              image_weights=opt.image_weights,
-                                              quad=opt.quad,
-                                              prefix=colorstr('train: '),
-                                              shuffle=True)
-    mlc = int(np.concatenate(dataset.labels, 0)[:, 0].max())  # max label class
-    nb = len(train_loader)  # number of batches
-    assert mlc < nc, f'Label class {mlc} exceeds nc={nc} in {data}. Possible class labels are 0-{nc - 1}'
-
-    # Process 0
-    if RANK in {-1, 0}:
-        val_loader = create_dataloader(val_path,
-                                       imgsz,
-                                       batch_size // WORLD_SIZE * 2,
-                                       gs,
-                                       single_cls,
-                                       hyp=hyp,
-                                       cache=None if noval else opt.cache,
-                                       rect=True,
-                                       rank=-1,
-                                       workers=workers * 2,
-                                       pad=0.5,
-                                       prefix=colorstr('val: '))[0]
-
-        if not resume:
-            labels = np.concatenate(dataset.labels, 0)
-            # c = torch.tensor(labels[:, 0])  # classes
-            # cf = torch.bincount(c.long(), minlength=nc) + 1.  # frequency
-            # model._initialize_biases(cf.to(device))
-            if plots:
-                plot_labels(labels, names, save_dir)
-
-            # Anchors
-            if not opt.noautoanchor:
-                check_anchors(dataset, model=model, thr=hyp['anchor_t'], imgsz=imgsz)
-            model.half().float()  # pre-reduce anchor precision
-
-        callbacks.run('on_pretrain_routine_end')
-
-    # DDP mode
-    if cuda and RANK != -1:
-        model = smart_DDP(model)
-
-    # Model attributes
-    nl = de_parallel(model).model[-1].nl  # number of detection layers (to scale hyps)
-    hyp['box'] *= 3 / nl  # scale to layers
-    hyp['cls'] *= nc / 80 * 3 / nl  # scale to classes and layers
-    hyp['obj'] *= (imgsz / 640) ** 2 * 3 / nl  # scale to image size and layers
-    hyp['label_smoothing'] = opt.label_smoothing
-    model.nc = nc  # attach number of classes to model
-    model.hyp = hyp  # attach hyperparameters to model
-    model.class_weights = labels_to_class_weights(dataset.labels, nc).to(device) * nc  # attach class weights
-    model.names = names
-
-    # Start training
-    t0 = time.time()
-    nw = max(round(hyp['warmup_epochs'] * nb), 100)  # number of warmup iterations, max(3 epochs, 100 iterations)
-    # nw = min(nw, (epochs - start_epoch) / 2 * nb)  # limit warmup to < 1/2 of training
-    last_opt_step = -1
-    maps = np.zeros(nc)  # mAP per class
-    results = (0, 0, 0, 0, 0, 0, 0)  # P, R, mAP@.5, mAP@.5-.95, val_loss(box, obj, cls)
-    scheduler.last_epoch = start_epoch - 1  # do not move
-    scaler = torch.cuda.amp.GradScaler(enabled=amp)
-    stopper, stop = EarlyStopping(patience=opt.patience), False
-    compute_loss = ComputeLoss(model)  # init loss class
-    callbacks.run('on_train_start')
-    LOGGER.info(f'Image sizes {imgsz} train, {imgsz} val\n'
-                f'Using {train_loader.num_workers * WORLD_SIZE} dataloader workers\n'
-                f"Logging results to {colorstr('bold', save_dir)}\n"
-                f'Starting training for {epochs} epochs...')
-    for epoch in range(start_epoch, epochs):  # epoch ------------------------------------------------------------------
-        callbacks.run('on_train_epoch_start')
-        model.train()
-
-        # Update image weights (optional, single-GPU only)
-        if opt.image_weights:
-            cw = model.class_weights.cpu().numpy() * (1 - maps) ** 2 / nc  # class weights
-            iw = labels_to_image_weights(dataset.labels, nc=nc, class_weights=cw)  # image weights
-            dataset.indices = random.choices(range(dataset.n), weights=iw, k=dataset.n)  # rand weighted idx
-
-        # Update mosaic border (optional)
-        # b = int(random.uniform(0.25 * imgsz, 0.75 * imgsz + gs) // gs * gs)
-        # dataset.mosaic_border = [b - imgsz, -b]  # height, width borders
-
-        mloss = torch.zeros(3, device=device)  # mean losses
-        if RANK != -1:
-            train_loader.sampler.set_epoch(epoch)
-        pbar = enumerate(train_loader)
-        LOGGER.info(('\n' + '%10s' * 7) % ('Epoch', 'gpu_mem', 'box', 'obj', 'cls', 'labels', 'img_size'))
-        if RANK in {-1, 0}:
-            pbar = tqdm(pbar, total=nb, bar_format='{l_bar}{bar:10}{r_bar}{bar:-10b}')  # progress bar
-        optimizer.zero_grad()
-        for i, (imgs, targets, paths, _) in pbar:  # batch -------------------------------------------------------------
-            callbacks.run('on_train_batch_start')
-            ni = i + nb * epoch  # number integrated batches (since train start)
-            imgs = imgs.to(device, non_blocking=True).float() / 255  # uint8 to float32, 0-255 to 0.0-1.0
-
-            # Warmup
-            if ni <= nw:
-                xi = [0, nw]  # x interp
-                # compute_loss.gr = np.interp(ni, xi, [0.0, 1.0])  # iou loss ratio (obj_loss = 1.0 or iou)
-                accumulate = max(1, np.interp(ni, xi, [1, nbs / batch_size]).round())
-                for j, x in enumerate(optimizer.param_groups):
-                    # bias lr falls from 0.1 to lr0, all other lrs rise from 0.0 to lr0
-                    x['lr'] = np.interp(ni, xi, [hyp['warmup_bias_lr'] if j == 0 else 0.0, x['initial_lr'] * lf(epoch)])
-                    if 'momentum' in x:
-                        x['momentum'] = np.interp(ni, xi, [hyp['warmup_momentum'], hyp['momentum']])
-
-            # Multi-scale
-            if opt.multi_scale:
-                sz = random.randrange(imgsz * 0.5, imgsz * 1.5 + gs) // gs * gs  # size
-                sf = sz / max(imgs.shape[2:])  # scale factor
-                if sf != 1:
-                    ns = [math.ceil(x * sf / gs) * gs for x in imgs.shape[2:]]  # new shape (stretched to gs-multiple)
-                    imgs = nn.functional.interpolate(imgs, size=ns, mode='bilinear', align_corners=False)
-
-            # Forward
-            with torch.cuda.amp.autocast(amp):
-                pred = model(imgs)  # forward
-                loss, loss_items = compute_loss(pred, targets.to(device))  # loss scaled by batch_size
-                if RANK != -1:
-                    loss *= WORLD_SIZE  # gradient averaged between devices in DDP mode
-                if opt.quad:
-                    loss *= 4.
-
-            # Backward
-            scaler.scale(loss).backward()
-
-            # Optimize
-            if ni - last_opt_step >= accumulate:
-                scaler.step(optimizer)  # optimizer.step
-                scaler.update()
-                optimizer.zero_grad()
-                if ema:
-                    ema.update(model)
-                last_opt_step = ni
-
-            # Log
-            if RANK in {-1, 0}:
-                mloss = (mloss * i + loss_items) / (i + 1)  # update mean losses
-                mem = f'{torch.cuda.memory_reserved() / 1E9 if torch.cuda.is_available() else 0:.3g}G'  # (GB)
-                pbar.set_description(('%10s' * 2 + '%10.4g' * 5) %
-                                     (f'{epoch}/{epochs - 1}', mem, *mloss, targets.shape[0], imgs.shape[-1]))
-                callbacks.run('on_train_batch_end', ni, model, imgs, targets, paths, plots)
-                if callbacks.stop_training:
-                    return
-            # end batch ------------------------------------------------------------------------------------------------
-
-        # Scheduler
-        lr = [x['lr'] for x in optimizer.param_groups]  # for loggers
-        scheduler.step()
-
-        if RANK in {-1, 0}:
-            # mAP
-            callbacks.run('on_train_epoch_end', epoch=epoch)
-            ema.update_attr(model, include=['yaml', 'nc', 'hyp', 'names', 'stride', 'class_weights'])
-            final_epoch = (epoch + 1 == epochs) or stopper.possible_stop
-            if not noval or final_epoch:  # Calculate mAP
-                results, maps, _ = val.run(data_dict,
-                                           batch_size=batch_size // WORLD_SIZE * 2,
-                                           imgsz=imgsz,
-                                           model=ema.ema,
-                                           single_cls=single_cls,
-                                           dataloader=val_loader,
-                                           save_dir=save_dir,
-                                           plots=False,
-                                           callbacks=callbacks,
-                                           compute_loss=compute_loss)
-
-            # Update best mAP
-            fi = fitness(np.array(results).reshape(1, -1))  # weighted combination of [P, R, mAP@.5, mAP@.5-.95]
-            stop = stopper(epoch=epoch, fitness=fi)  # early stop check
-            if fi > best_fitness:
-                best_fitness = fi
-            log_vals = list(mloss) + list(results) + lr
-            callbacks.run('on_fit_epoch_end', log_vals, epoch, best_fitness, fi)
-
-            # Save model
-            if (not nosave) or (final_epoch and not evolve):  # if save
-                ckpt = {
-                    'epoch': epoch,
-                    'best_fitness': best_fitness,
-                    'model': deepcopy(de_parallel(model)).half(),
-                    'ema': deepcopy(ema.ema).half(),
-                    'updates': ema.updates,
-                    'optimizer': optimizer.state_dict(),
-                    'wandb_id': loggers.wandb.wandb_run.id if loggers.wandb else None,
-                    'date': datetime.now().isoformat()}
-
-                # Save last, best and delete
-                torch.save(ckpt, last)
-                if best_fitness == fi:
-                    torch.save(ckpt, best)
-                if opt.save_period > 0 and epoch % opt.save_period == 0:
-                    torch.save(ckpt, w / f'epoch{epoch}.pt')
-                del ckpt
-                callbacks.run('on_model_save', last, epoch, final_epoch, best_fitness, fi)
-
-        # EarlyStopping
-        if RANK != -1:  # if DDP training
-            broadcast_list = [stop if RANK == 0 else None]
-            dist.broadcast_object_list(broadcast_list, 0)  # broadcast 'stop' to all ranks
-            if RANK != 0:
-                stop = broadcast_list[0]
-        if stop:
-            break  # must break all DDP ranks
-
-        # end epoch ----------------------------------------------------------------------------------------------------
-    # end training -----------------------------------------------------------------------------------------------------
-    if RANK in {-1, 0}:
-        LOGGER.info(f'\n{epoch - start_epoch + 1} epochs completed in {(time.time() - t0) / 3600:.3f} hours.')
-        for f in last, best:
-            if f.exists():
-                strip_optimizer(f)  # strip optimizers
-                if f is best:
-                    LOGGER.info(f'\nValidating {f}...')
-                    results, _, _ = val.run(
-                        data_dict,
-                        batch_size=batch_size // WORLD_SIZE * 2,
-                        imgsz=imgsz,
-                        model=attempt_load(f, device).half(),
-                        iou_thres=0.65 if is_coco else 0.60,  # best pycocotools results at 0.65
-                        single_cls=single_cls,
-                        dataloader=val_loader,
-                        save_dir=save_dir,
-                        save_json=is_coco,
-                        verbose=True,
-                        plots=plots,
-                        callbacks=callbacks,
-                        compute_loss=compute_loss)  # val best model with plots
-                    if is_coco:
-                        callbacks.run('on_fit_epoch_end', list(mloss) + list(results) + lr, epoch, best_fitness, fi)
-
-        callbacks.run('on_train_end', last, best, plots, epoch, results)
-
-    torch.cuda.empty_cache()
-    return results
-
-
-def parse_opt(known=False):
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--weights', type=str, default=ROOT / 'yolov5s.pt', help='initial weights path')
-    parser.add_argument('--cfg', type=str, default='', help='model.yaml path')
-    parser.add_argument('--data', type=str, default=ROOT / 'data/coco128.yaml', help='dataset.yaml path')
-    parser.add_argument('--hyp', type=str, default=ROOT / 'data/hyps/hyp.scratch-low.yaml', help='hyperparameters path')
-    parser.add_argument('--epochs', type=int, default=300)
-    parser.add_argument('--batch-size', type=int, default=16, help='total batch size for all GPUs, -1 for autobatch')
-    parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=640, help='train, val image size (pixels)')
-    parser.add_argument('--rect', action='store_true', help='rectangular training')
-    parser.add_argument('--resume', nargs='?', const=True, default=False, help='resume most recent training')
-    parser.add_argument('--nosave', action='store_true', help='only save final checkpoint')
-    parser.add_argument('--noval', action='store_true', help='only validate final epoch')
-    parser.add_argument('--noautoanchor', action='store_true', help='disable AutoAnchor')
-    parser.add_argument('--noplots', action='store_true', help='save no plot files')
-    parser.add_argument('--evolve', type=int, nargs='?', const=300, help='evolve hyperparameters for x generations')
-    parser.add_argument('--bucket', type=str, default='', help='gsutil bucket')
-    parser.add_argument('--cache', type=str, nargs='?', const='ram', help='--cache images in "ram" (default) or "disk"')
-    parser.add_argument('--image-weights', action='store_true', help='use weighted image selection for training')
-    parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
-    parser.add_argument('--multi-scale', action='store_true', help='vary img-size +/- 50%%')
-    parser.add_argument('--single-cls', action='store_true', help='train multi-class data as single-class')
-    parser.add_argument('--optimizer', type=str, choices=['SGD', 'Adam', 'AdamW'], default='SGD', help='optimizer')
-    parser.add_argument('--sync-bn', action='store_true', help='use SyncBatchNorm, only available in DDP mode')
-    parser.add_argument('--workers', type=int, default=8, help='max dataloader workers (per RANK in DDP mode)')
-    parser.add_argument('--project', default=ROOT / 'runs/train', help='save to project/name')
-    parser.add_argument('--name', default='exp', help='save to project/name')
-    parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
-    parser.add_argument('--quad', action='store_true', help='quad dataloader')
-    parser.add_argument('--cos-lr', action='store_true', help='cosine LR scheduler')
-    parser.add_argument('--label-smoothing', type=float, default=0.0, help='Label smoothing epsilon')
-    parser.add_argument('--patience', type=int, default=100, help='EarlyStopping patience (epochs without improvement)')
-    parser.add_argument('--freeze', nargs='+', type=int, default=[0], help='Freeze layers: backbone=10, first3=0 1 2')
-    parser.add_argument('--save-period', type=int, default=-1, help='Save checkpoint every x epochs (disabled if < 1)')
-    parser.add_argument('--seed', type=int, default=0, help='Global training seed')
-    parser.add_argument('--local_rank', type=int, default=-1, help='Automatic DDP Multi-GPU argument, do not modify')
-
-    # Weights & Biases arguments
-    parser.add_argument('--entity', default=None, help='W&B: Entity')
-    parser.add_argument('--upload_dataset', nargs='?', const=True, default=False, help='W&B: Upload data, "val" option')
-    parser.add_argument('--bbox_interval', type=int, default=-1, help='W&B: Set bounding-box image logging interval')
-    parser.add_argument('--artifact_alias', type=str, default='latest', help='W&B: Version of dataset artifact to use')
-
-    opt = parser.parse_known_args()[0] if known else parser.parse_args()
-    return opt
-
-
-def main(opt, callbacks=Callbacks()):
-    # Checks
-    if RANK in {-1, 0}:
-        print_args(vars(opt))
-        check_git_status()
-        check_requirements(exclude=['thop'])
-
-    # Resume
-    if opt.resume and not check_wandb_resume(opt) and not opt.evolve:  # resume an interrupted run
-        ckpt = opt.resume if isinstance(opt.resume, str) else get_latest_run()  # specified or most recent path
-        assert os.path.isfile(ckpt), 'ERROR: --resume checkpoint does not exist'
-        with open(Path(ckpt).parent.parent / 'opt.yaml', errors='ignore') as f:
-            opt = argparse.Namespace(**yaml.safe_load(f))  # replace
-        opt.cfg, opt.weights, opt.resume = '', ckpt, True  # reinstate
-        LOGGER.info(f'Resuming training from {ckpt}')
-    else:
-        opt.data, opt.cfg, opt.hyp, opt.weights, opt.project = \
-            check_file(opt.data), check_yaml(opt.cfg), check_yaml(opt.hyp), str(opt.weights), str(opt.project)  # checks
-        assert len(opt.cfg) or len(opt.weights), 'either --cfg or --weights must be specified'
-        if opt.evolve:
-            if opt.project == str(ROOT / 'runs/train'):  # if default project name, rename to runs/evolve
-                opt.project = str(ROOT / 'runs/evolve')
-            opt.exist_ok, opt.resume = opt.resume, False  # pass resume to exist_ok and disable resume
-        if opt.name == 'cfg':
-            opt.name = Path(opt.cfg).stem  # use model.yaml as name
-        opt.save_dir = str(increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok))
-
-    # DDP mode
-    device = select_device(opt.device, batch_size=opt.batch_size)
-    if LOCAL_RANK != -1:
-        msg = 'is not compatible with YOLOv5 Multi-GPU DDP training'
-        assert not opt.image_weights, f'--image-weights {msg}'
-        assert not opt.evolve, f'--evolve {msg}'
-        assert opt.batch_size != -1, f'AutoBatch with --batch-size -1 {msg}, please pass a valid --batch-size'
-        assert opt.batch_size % WORLD_SIZE == 0, f'--batch-size {opt.batch_size} must be multiple of WORLD_SIZE'
-        assert torch.cuda.device_count() > LOCAL_RANK, 'insufficient CUDA devices for DDP command'
-        torch.cuda.set_device(LOCAL_RANK)
-        device = torch.device('cuda', LOCAL_RANK)
-        dist.init_process_group(backend="nccl" if dist.is_nccl_available() else "gloo")
-
-    # Train
-    if not opt.evolve:
-        train(opt.hyp, opt, device, callbacks)
-        if WORLD_SIZE > 1 and RANK == 0:
-            LOGGER.info('Destroying process group... ')
-            dist.destroy_process_group()
-
-    # Evolve hyperparameters (optional)
-    else:
-        # Hyperparameter evolution metadata (mutation scale 0-1, lower_limit, upper_limit)
-        meta = {
-            'lr0': (1, 1e-5, 1e-1),  # initial learning rate (SGD=1E-2, Adam=1E-3)
-            'lrf': (1, 0.01, 1.0),  # final OneCycleLR learning rate (lr0 * lrf)
-            'momentum': (0.3, 0.6, 0.98),  # SGD momentum/Adam beta1
-            'weight_decay': (1, 0.0, 0.001),  # optimizer weight decay
-            'warmup_epochs': (1, 0.0, 5.0),  # warmup epochs (fractions ok)
-            'warmup_momentum': (1, 0.0, 0.95),  # warmup initial momentum
-            'warmup_bias_lr': (1, 0.0, 0.2),  # warmup initial bias lr
-            'box': (1, 0.02, 0.2),  # box loss gain
-            'cls': (1, 0.2, 4.0),  # cls loss gain
-            'cls_pw': (1, 0.5, 2.0),  # cls BCELoss positive_weight
-            'obj': (1, 0.2, 4.0),  # obj loss gain (scale with pixels)
-            'obj_pw': (1, 0.5, 2.0),  # obj BCELoss positive_weight
-            'iou_t': (0, 0.1, 0.7),  # IoU training threshold
-            'anchor_t': (1, 2.0, 8.0),  # anchor-multiple threshold
-            'anchors': (2, 2.0, 10.0),  # anchors per output grid (0 to ignore)
-            'fl_gamma': (0, 0.0, 2.0),  # focal loss gamma (efficientDet default gamma=1.5)
-            'hsv_h': (1, 0.0, 0.1),  # image HSV-Hue augmentation (fraction)
-            'hsv_s': (1, 0.0, 0.9),  # image HSV-Saturation augmentation (fraction)
-            'hsv_v': (1, 0.0, 0.9),  # image HSV-Value augmentation (fraction)
-            'degrees': (1, 0.0, 45.0),  # image rotation (+/- deg)
-            'translate': (1, 0.0, 0.9),  # image translation (+/- fraction)
-            'scale': (1, 0.0, 0.9),  # image scale (+/- gain)
-            'shear': (1, 0.0, 10.0),  # image shear (+/- deg)
-            'perspective': (0, 0.0, 0.001),  # image perspective (+/- fraction), range 0-0.001
-            'flipud': (1, 0.0, 1.0),  # image flip up-down (probability)
-            'fliplr': (0, 0.0, 1.0),  # image flip left-right (probability)
-            'mosaic': (1, 0.0, 1.0),  # image mixup (probability)
-            'mixup': (1, 0.0, 1.0),  # image mixup (probability)
-            'copy_paste': (1, 0.0, 1.0)}  # segment copy-paste (probability)
-
-        with open(opt.hyp, errors='ignore') as f:
-            hyp = yaml.safe_load(f)  # load hyps dict
-            if 'anchors' not in hyp:  # anchors commented in hyp.yaml
-                hyp['anchors'] = 3
-        opt.noval, opt.nosave, save_dir = True, True, Path(opt.save_dir)  # only val/save final epoch
-        # ei = [isinstance(x, (int, float)) for x in hyp.values()]  # evolvable indices
-        evolve_yaml, evolve_csv = save_dir / 'hyp_evolve.yaml', save_dir / 'evolve.csv'
-        if opt.bucket:
-            os.system(f'gsutil cp gs://{opt.bucket}/evolve.csv {evolve_csv}')  # download evolve.csv if exists
-
-        for _ in range(opt.evolve):  # generations to evolve
-            if evolve_csv.exists():  # if evolve.csv exists: select best hyps and mutate
-                # Select parent(s)
-                parent = 'single'  # parent selection method: 'single' or 'weighted'
-                x = np.loadtxt(evolve_csv, ndmin=2, delimiter=',', skiprows=1)
-                n = min(5, len(x))  # number of previous results to consider
-                x = x[np.argsort(-fitness(x))][:n]  # top n mutations
-                w = fitness(x) - fitness(x).min() + 1E-6  # weights (sum > 0)
-                if parent == 'single' or len(x) == 1:
-                    # x = x[random.randint(0, n - 1)]  # random selection
-                    x = x[random.choices(range(n), weights=w)[0]]  # weighted selection
-                elif parent == 'weighted':
-                    x = (x * w.reshape(n, 1)).sum(0) / w.sum()  # weighted combination
-
-                # Mutate
-                mp, s = 0.8, 0.2  # mutation probability, sigma
-                npr = np.random
-                npr.seed(int(time.time()))
-                g = np.array([meta[k][0] for k in hyp.keys()])  # gains 0-1
-                ng = len(meta)
-                v = np.ones(ng)
-                while all(v == 1):  # mutate until a change occurs (prevent duplicates)
-                    v = (g * (npr.random(ng) < mp) * npr.randn(ng) * npr.random() * s + 1).clip(0.3, 3.0)
-                for i, k in enumerate(hyp.keys()):  # plt.hist(v.ravel(), 300)
-                    hyp[k] = float(x[i + 7] * v[i])  # mutate
-
-            # Constrain to limits
-            for k, v in meta.items():
-                hyp[k] = max(hyp[k], v[1])  # lower limit
-                hyp[k] = min(hyp[k], v[2])  # upper limit
-                hyp[k] = round(hyp[k], 5)  # significant digits
-
-            # Train mutation
-            results = train(hyp.copy(), opt, device, callbacks)
-            callbacks = Callbacks()
-            # Write mutation results
-            print_mutation(results, hyp.copy(), save_dir, opt.bucket)
-
-        # Plot results
-        plot_evolve(evolve_csv)
-        LOGGER.info(f'Hyperparameter evolution finished {opt.evolve} generations\n'
-                    f"Results saved to {colorstr('bold', save_dir)}\n"
-                    f'Usage example: $ python train.py --hyp {evolve_yaml}')
-
-
-def run(**kwargs):
-    # Usage: import train; train.run(data='coco128.yaml', imgsz=320, weights='yolov5m.pt')
-    opt = parse_opt(True)
-    for k, v in kwargs.items():
-        setattr(opt, k, v)
-    main(opt)
-    return opt
-
-
-if __name__ == "__main__":
-    opt = parse_opt()
-    main(opt)
diff --git a/spaces/xiongjie/face-expression-ja-example/app.py b/spaces/xiongjie/face-expression-ja-example/app.py
deleted file mode 100644
index 8b1ae25c4b4e3f125000e0a577bbd3f0eb376af1..0000000000000000000000000000000000000000
--- a/spaces/xiongjie/face-expression-ja-example/app.py
+++ /dev/null
@@ -1,20 +0,0 @@
-import gradio as gr
-import emoji
-from simpletransformers.classification import ClassificationModel, ClassificationArgs
-
-CLASS_NAMES = ['angry_face', 'crying_face', 'face_with_crossed-out_eyes', 'face_with_open_mouth', 'flushed_face', 'grinning_face_with_smiling_eyes', 'loudly_crying_face', 'pouting_face', 'slightly_smiling_face', 'smiling_face_with_smiling_eyes', 'sparkles', 'tired_face']
-
-model_args = ClassificationArgs()
-model_original = ClassificationModel(
-    'auto',
-    'xiongjie/face-expression-ja',
-    use_cuda=False,
-    args=model_args,
-    num_labels=len(CLASS_NAMES)
-)
-
-def predict_emoticon(text):
-    return emoji.emojize(":" + CLASS_NAMES[model_original.predict([text])[0][0]] + ":")
-
-iface = gr.Interface(fn=predict_emoticon, inputs="text", outputs="text")
-iface.launch()
\ No newline at end of file
diff --git a/spaces/yderre-aubay/midi-player-demo/src/main/hooks/useStores.ts b/spaces/yderre-aubay/midi-player-demo/src/main/hooks/useStores.ts
deleted file mode 100644
index 633bf76b265b7be4ee501b914fee6a83e2d1f185..0000000000000000000000000000000000000000
--- a/spaces/yderre-aubay/midi-player-demo/src/main/hooks/useStores.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { createContext, useContext } from "react"
-import RootStore from "../stores/RootStore"
-
-export const StoreContext = createContext<RootStore>(
-  null as unknown as RootStore, // never use default value
-)
-export const useStores = () => useContext(StoreContext)
diff --git a/spaces/ygangang/CodeFormer/app.py b/spaces/ygangang/CodeFormer/app.py
deleted file mode 100644
index 5f4ac56e2c2b11da2ea212a70eaafc3917719245..0000000000000000000000000000000000000000
--- a/spaces/ygangang/CodeFormer/app.py
+++ /dev/null
@@ -1,271 +0,0 @@
-"""
-This file is used for deploying hugging face demo:
-https://huggingface.co/spaces/sczhou/CodeFormer
-"""
-
-import sys
-sys.path.append('CodeFormer')
-import os
-import cv2
-import torch
-import torch.nn.functional as F
-import gradio as gr
-
-from torchvision.transforms.functional import normalize
-
-from basicsr.utils import imwrite, img2tensor, tensor2img
-from basicsr.utils.download_util import load_file_from_url
-from facelib.utils.face_restoration_helper import FaceRestoreHelper
-from facelib.utils.misc import is_gray
-from basicsr.archs.rrdbnet_arch import RRDBNet
-from basicsr.utils.realesrgan_utils import RealESRGANer
-
-from basicsr.utils.registry import ARCH_REGISTRY
-
-
-os.system("pip freeze")
-
-pretrain_model_url = {
-    'codeformer': 'https://github.com/sczhou/CodeFormer/releases/download/v0.1.0/codeformer.pth',
-    'detection': 'https://github.com/sczhou/CodeFormer/releases/download/v0.1.0/detection_Resnet50_Final.pth',
-    'parsing': 'https://github.com/sczhou/CodeFormer/releases/download/v0.1.0/parsing_parsenet.pth',
-    'realesrgan': 'https://github.com/sczhou/CodeFormer/releases/download/v0.1.0/RealESRGAN_x2plus.pth'
-}
-# download weights
-if not os.path.exists('CodeFormer/weights/CodeFormer/codeformer.pth'):
-    load_file_from_url(url=pretrain_model_url['codeformer'], model_dir='CodeFormer/weights/CodeFormer', progress=True, file_name=None)
-if not os.path.exists('CodeFormer/weights/facelib/detection_Resnet50_Final.pth'):
-    load_file_from_url(url=pretrain_model_url['detection'], model_dir='CodeFormer/weights/facelib', progress=True, file_name=None)
-if not os.path.exists('CodeFormer/weights/facelib/parsing_parsenet.pth'):
-    load_file_from_url(url=pretrain_model_url['parsing'], model_dir='CodeFormer/weights/facelib', progress=True, file_name=None)
-if not os.path.exists('CodeFormer/weights/realesrgan/RealESRGAN_x2plus.pth'):
-    load_file_from_url(url=pretrain_model_url['realesrgan'], model_dir='CodeFormer/weights/realesrgan', progress=True, file_name=None)
-
-# download images
-torch.hub.download_url_to_file(
-    'https://replicate.com/api/models/sczhou/codeformer/files/fa3fe3d1-76b0-4ca8-ac0d-0a925cb0ff54/06.png',
-    '01.png')
-torch.hub.download_url_to_file(
-    'https://replicate.com/api/models/sczhou/codeformer/files/a1daba8e-af14-4b00-86a4-69cec9619b53/04.jpg',
-    '02.jpg')
-torch.hub.download_url_to_file(
-    'https://replicate.com/api/models/sczhou/codeformer/files/542d64f9-1712-4de7-85f7-3863009a7c3d/03.jpg',
-    '03.jpg')
-torch.hub.download_url_to_file(
-    'https://replicate.com/api/models/sczhou/codeformer/files/a11098b0-a18a-4c02-a19a-9a7045d68426/010.jpg',
-    '04.jpg')
-torch.hub.download_url_to_file(
-    'https://replicate.com/api/models/sczhou/codeformer/files/7cf19c2c-e0cf-4712-9af8-cf5bdbb8d0ee/012.jpg',
-    '05.jpg')
-
-def imread(img_path):
-    img = cv2.imread(img_path)
-    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    return img
-
-# set enhancer with RealESRGAN
-def set_realesrgan():
-    half = True if torch.cuda.is_available() else False
-    model = RRDBNet(
-        num_in_ch=3,
-        num_out_ch=3,
-        num_feat=64,
-        num_block=23,
-        num_grow_ch=32,
-        scale=2,
-    )
-    upsampler = RealESRGANer(
-        scale=2,
-        model_path="CodeFormer/weights/realesrgan/RealESRGAN_x2plus.pth",
-        model=model,
-        tile=400,
-        tile_pad=40,
-        pre_pad=0,
-        half=half,
-    )
-    return upsampler
-
-upsampler = set_realesrgan()
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-codeformer_net = ARCH_REGISTRY.get("CodeFormer")(
-    dim_embd=512,
-    codebook_size=1024,
-    n_head=8,
-    n_layers=9,
-    connect_list=["32", "64", "128", "256"],
-).to(device)
-ckpt_path = "CodeFormer/weights/CodeFormer/codeformer.pth"
-checkpoint = torch.load(ckpt_path)["params_ema"]
-codeformer_net.load_state_dict(checkpoint)
-codeformer_net.eval()
-
-os.makedirs('output', exist_ok=True)
-
-def inference(image, background_enhance, face_upsample, upscale, codeformer_fidelity):
-    """Run a single prediction on the model"""
-    try: # global try
-        # take the default setting for the demo
-        has_aligned = False
-        only_center_face = False
-        draw_box = False
-        detection_model = "retinaface_resnet50"
-        print('Inp:', image, background_enhance, face_upsample, upscale, codeformer_fidelity)
-
-        img = cv2.imread(str(image), cv2.IMREAD_COLOR)
-        print('\timage size:', img.shape)
-
-        upscale = int(upscale) # covert type to int
-        if upscale > 4:
-            upscale = 4  # avoid momory exceeded due to too large upscale
-        if upscale > 2 and min(img.shape[:2])>1280:
-            upscale = 2  # avoid momory exceeded due to too large img resolution
-
-        face_helper = FaceRestoreHelper(
-            upscale,
-            face_size=512,
-            crop_ratio=(1, 1),
-            det_model=detection_model,
-            save_ext="png",
-            use_parse=True,
-            device=device,
-        )
-        bg_upsampler = upsampler if background_enhance else None
-        face_upsampler = upsampler if face_upsample else None
-
-
-        if has_aligned:
-            # the input faces are already cropped and aligned
-            img = cv2.resize(img, (512, 512), interpolation=cv2.INTER_LINEAR)
-            face_helper.is_gray = is_gray(img, threshold=5)
-            if face_helper.is_gray:
-                print('\tgrayscale input: True')
-            face_helper.cropped_faces = [img]
-        else:
-            face_helper.read_image(img)
-            # get face landmarks for each face
-            num_det_faces = face_helper.get_face_landmarks_5(
-            only_center_face=only_center_face, resize=640, eye_dist_threshold=5
-            )
-            print(f'\tdetect {num_det_faces} faces')
-            # align and warp each face
-            face_helper.align_warp_face()
-
-        # face restoration for each cropped face
-        for idx, cropped_face in enumerate(face_helper.cropped_faces):
-            # prepare data
-            cropped_face_t = img2tensor(
-                cropped_face / 255.0, bgr2rgb=True, float32=True
-            )
-            normalize(cropped_face_t, (0.5, 0.5, 0.5), (0.5, 0.5, 0.5), inplace=True)
-            cropped_face_t = cropped_face_t.unsqueeze(0).to(device)
-
-            try:
-                with torch.no_grad():
-                    output = codeformer_net(
-                        cropped_face_t, w=codeformer_fidelity, adain=True
-                    )[0]
-                    restored_face = tensor2img(output, rgb2bgr=True, min_max=(-1, 1))
-                del output
-                torch.cuda.empty_cache()
-            except RuntimeError as error:
-                print(f"Failed inference for CodeFormer: {error}")
-                restored_face = tensor2img(
-                    cropped_face_t, rgb2bgr=True, min_max=(-1, 1)
-                )
-
-            restored_face = restored_face.astype("uint8")
-            face_helper.add_restored_face(restored_face)
-
-        # paste_back
-        if not has_aligned:
-            # upsample the background
-            if bg_upsampler is not None:
-                # Now only support RealESRGAN for upsampling background
-                bg_img = bg_upsampler.enhance(img, outscale=upscale)[0]
-            else:
-                bg_img = None
-            face_helper.get_inverse_affine(None)
-            # paste each restored face to the input image
-            if face_upsample and face_upsampler is not None:
-                restored_img = face_helper.paste_faces_to_input_image(
-                    upsample_img=bg_img,
-                    draw_box=draw_box,
-                    face_upsampler=face_upsampler,
-                )
-            else:
-                restored_img = face_helper.paste_faces_to_input_image(
-                    upsample_img=bg_img, draw_box=draw_box
-                )
-
-        # save restored img
-        save_path = f'output/out.png'
-        imwrite(restored_img, str(save_path))
-
-        restored_img = cv2.cvtColor(restored_img, cv2.COLOR_BGR2RGB)
-        return restored_img, save_path
-    except Exception as error:
-        print('Global exception', error)
-        return None, None
-
-
-title = "CodeFormer: 强大的面部修复和增强网络"
-description = r"""<center><img src='https://user-images.githubusercontent.com/14334509/189166076-94bb2cac-4f4e-40fb-a69f-66709e3d98f5.png' alt='CodeFormer logo'></center>
-本页面是为方便英语不太好朋友了解如何使用，采用的是CPU，运算时间较长，请移步<b><a href='https://huggingface.co/spaces/sczhou/CodeFormer'>官方Gradio示例</a>获取更好效果</b> for <a href='https://github.com/sczhou/CodeFormer' target='_blank'><b>Towards Robust Blind Face Restoration with Codebook Lookup Transformer (NeurIPS 2022)</b></a>.<br>
-🔥 CodeFormer对于老照片和由AI生成人脸的强大的面部恢复算法.<br>
-🤗 使用CodeFormer来提高stable-diffusion的生成效果!<br>
-"""
-article = r"""
-如果CodeFormer对你有帮助, 请在 <a href='https://github.com/sczhou/CodeFormer' target='_blank'>Github Repo</a>点 ⭐. 谢谢! 
-[![GitHub Stars](https://img.shields.io/github/stars/sczhou/CodeFormer?style=social)](https://github.com/sczhou/CodeFormer)
-
----
-<h2 style="font-weight: 900; margin-bottom: 7px;">点击<a href='https://www.toolchest.cn' target='_blank'>返回智能工具箱</a>查看更多好玩的人工智能项目</h2>
-📝 **Citation**
-
-If our work is useful for your research, please consider citing:
-```bibtex
-@inproceedings{zhou2022codeformer,
-    author = {Zhou, Shangchen and Chan, Kelvin C.K. and Li, Chongyi and Loy, Chen Change},
-    title = {Towards Robust Blind Face Restoration with Codebook Lookup TransFormer},
-    booktitle = {NeurIPS},
-    year = {2022}
-}
-```
-
-📋 **License**
-
-This project is licensed under <a rel="license" href="https://github.com/sczhou/CodeFormer/blob/master/LICENSE">S-Lab License 1.0</a>. 
-Redistribution and use for non-commercial purposes should follow this license.
-
-📧 **Contact**
-
-If you have any questions, please feel free to reach me out at <b>shangchenzhou@gmail.com</b>.
-
-![visitors](https://visitor-badge.laobi.icu/badge?page_id=sczhou/CodeFormer)
-"""
-
-demo = gr.Interface(
-    inference, [
-        gr.inputs.Image(type="filepath", label="输入"),
-        gr.inputs.Checkbox(default=True, label="背景增强"),
-        gr.inputs.Checkbox(default=True, label="面部增强"),
-        gr.inputs.Number(default=2, label="放大倍数 (最大4倍)"),
-        gr.Slider(0, 1, value=0.5, step=0.01, label='Codeformer_Fidelity (0 for better quality, 1 for better identity)')
-    ], [
-        gr.outputs.Image(type="numpy", label="输出"),
-        gr.outputs.File(label="下载输出")
-    ],
-    title=title,
-    description=description,
-    article=article,       
-    examples=[
-        ['01.png', True, True, 2, 0.7],
-        ['02.jpg', True, True, 2, 0.7],
-        ['03.jpg', True, True, 2, 0.7],
-        ['04.jpg', True, True, 2, 0.1],
-        ['05.jpg', True, True, 2, 0.1]
-      ]
-    )
-
-demo.queue(concurrency_count=4)
-demo.launch()
\ No newline at end of file
diff --git a/spaces/yizhangliu/Grounded-Segment-Anything/transformers_4_35_0/generation/tf_utils.py b/spaces/yizhangliu/Grounded-Segment-Anything/transformers_4_35_0/generation/tf_utils.py
deleted file mode 100644
index 3c3d7c553149c1fee13705b03f29f8393ea3f2c0..0000000000000000000000000000000000000000
--- a/spaces/yizhangliu/Grounded-Segment-Anything/transformers_4_35_0/generation/tf_utils.py
+++ /dev/null
@@ -1,3158 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
-# Copyright (c) 2018, 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.
-
-import copy
-import inspect
-import warnings
-from dataclasses import dataclass
-from typing import Any, Dict, Optional, Tuple, Union
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.compiler.tf2xla.python.xla import dynamic_update_slice
-
-from ..modeling_tf_outputs import TFCausalLMOutputWithPast, TFSeq2SeqLMOutput
-from ..models.auto import (
-    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
-    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
-    TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
-    TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
-)
-from ..tf_utils import shape_list, stable_softmax
-from ..utils import ModelOutput, logging
-from .configuration_utils import GenerationConfig
-from .tf_logits_process import (
-    TFForcedBOSTokenLogitsProcessor,
-    TFForcedEOSTokenLogitsProcessor,
-    TFForceTokensLogitsProcessor,
-    TFLogitsProcessorList,
-    TFMinLengthLogitsProcessor,
-    TFNoBadWordsLogitsProcessor,
-    TFNoRepeatNGramLogitsProcessor,
-    TFRepetitionPenaltyLogitsProcessor,
-    TFSuppressTokensAtBeginLogitsProcessor,
-    TFSuppressTokensLogitsProcessor,
-    TFTemperatureLogitsWarper,
-    TFTopKLogitsWarper,
-    TFTopPLogitsWarper,
-)
-
-
-logger = logging.get_logger(__name__)
-
-
-@dataclass
-class TFGreedySearchDecoderOnlyOutput(ModelOutput):
-    """
-    Base class for outputs of decoder-only generation models using greedy search.
-
-
-    Args:
-        sequences (`tf.Tensor` of shape `(batch_size, sequence_length)`):
-            The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter
-            if all batches finished early due to the `eos_token_id`.
-        scores (`tuple(tf.Tensor)` *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax)
-            at each generation step. Tuple of `tf.Tensor` with up to `max_new_tokens` elements (one element for each
-            generated token), with each tensor of shape `(batch_size, config.vocab_size)`.
-        attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, num_heads, generated_length, sequence_length)`.
-        hidden_states (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, generated_length, hidden_size)`.
-    """
-
-    sequences: tf.Tensor = None
-    scores: Optional[Tuple[tf.Tensor]] = None
-    attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    hidden_states: Optional[Tuple[Tuple[tf.Tensor]]] = None
-
-
-@dataclass
-class TFGreedySearchEncoderDecoderOutput(ModelOutput):
-    """
-    Base class for outputs of encoder-decoder generation models using greedy search. Hidden states and attention
-    weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the
-    encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
-
-
-    Args:
-        sequences (`tf.Tensor` of shape `(batch_size, sequence_length)`):
-            The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter
-            if all batches finished early due to the `eos_token_id`.
-        scores (`tuple(tf.Tensor)` *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax)
-            at each generation step. Tuple of `tf.Tensor` with up to `max_new_tokens` elements (one element for each
-            generated token), with each tensor of shape `(batch_size, config.vocab_size)`.
-        encoder_attentions (`tuple(tf.Tensor)`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple of `tf.Tensor` (one for each layer of the decoder) of shape `(batch_size, num_heads, sequence_length,
-            sequence_length)`.
-        encoder_hidden_states (`tuple(tf.Tensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple of `tf.Tensor` (one for the output of the embeddings + one for the output of each layer) of shape
-            `(batch_size, sequence_length, hidden_size)`.
-        decoder_attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, num_heads, generated_length, sequence_length)`.
-        cross_attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, num_heads, generated_length, sequence_length)`.
-        decoder_hidden_states (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, generated_length, hidden_size)`.
-    """
-
-    sequences: tf.Tensor = None
-    scores: Optional[Tuple[tf.Tensor]] = None
-    encoder_attentions: Optional[Tuple[tf.Tensor]] = None
-    encoder_hidden_states: Optional[Tuple[tf.Tensor]] = None
-    decoder_attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    cross_attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    decoder_hidden_states: Optional[Tuple[Tuple[tf.Tensor]]] = None
-
-
-@dataclass
-class TFSampleDecoderOnlyOutput(ModelOutput):
-    """
-    Base class for outputs of decoder-only generation models using sampling.
-
-
-    Args:
-        sequences (`tf.Tensor` of shape `(batch_size*num_return_sequences, sequence_length)`):
-            The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter
-            if all batches finished early due to the `eos_token_id`.
-        scores (`tuple(tf.Tensor)` *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax)
-            at each generation step. Tuple of `tf.Tensor` with up to `max_new_tokens` elements (one element for each
-            generated token), with each tensor of shape `(batch_size*num_return_sequences, config.vocab_size)`.
-        attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(num_return_sequences*batch_size, num_heads, generated_length, sequence_length)`.
-        hidden_states (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(num_return_sequences*batch_size, generated_length, hidden_size)`.
-    """
-
-    sequences: tf.Tensor = None
-    scores: Optional[Tuple[tf.Tensor]] = None
-    attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    hidden_states: Optional[Tuple[Tuple[tf.Tensor]]] = None
-
-
-@dataclass
-class TFSampleEncoderDecoderOutput(ModelOutput):
-    """
-    Base class for outputs of encoder-decoder generation models using sampling. Hidden states and attention weights of
-    the decoder (respectively the encoder) can be accessed via the encoder_attentions and the encoder_hidden_states
-    attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
-
-
-    Args:
-        sequences (`tf.Tensor` of shape `(batch_size*num_return_sequences, sequence_length)`):
-            The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter
-            if all batches finished early due to the `eos_token_id`.
-        scores (`tuple(tf.Tensor)` *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax)
-            at each generation step. Tuple of `tf.Tensor` with up to `max_new_tokens` elements (one element for each
-            generated token), with each tensor of shape `(batch_size*num_return_sequences, config.vocab_size)`.
-        encoder_attentions (`tuple(tf.Tensor)`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple of `tf.Tensor` (one for each layer of the decoder) of shape `(batch_size*num_return_sequences,
-            num_heads, sequence_length, sequence_length)`.
-        encoder_hidden_states (`tuple(tf.Tensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple of `tf.Tensor` (one for the output of the embeddings + one for the output of each layer) of shape
-            `(batch_size*num_return_sequences, sequence_length, hidden_size)`.
-        decoder_attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size*num_return_sequences, num_heads, generated_length, sequence_length)`.
-        cross_attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, num_heads, generated_length, sequence_length)`.
-        decoder_hidden_states (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size*num_return_sequences, generated_length, hidden_size)`.
-    """
-
-    sequences: tf.Tensor = None
-    scores: Optional[Tuple[tf.Tensor]] = None
-    encoder_attentions: Optional[Tuple[tf.Tensor]] = None
-    encoder_hidden_states: Optional[Tuple[tf.Tensor]] = None
-    decoder_attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    cross_attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    decoder_hidden_states: Optional[Tuple[Tuple[tf.Tensor]]] = None
-
-
-@dataclass
-class TFBeamSearchDecoderOnlyOutput(ModelOutput):
-    """
-    Base class for outputs of decoder-only generation models using beam search.
-
-    Args:
-        sequences (`tf.Tensor` of shape `(batch_size*num_return_sequences, sequence_length)`):
-            The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter
-            if all batches finished early due to the `eos_token_id`.
-        sequences_scores (`tf.Tensor` of shape `(batch_size*num_return_sequences)`, *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Final beam scores of the generated `sequences`.
-        scores (`tuple(tf.Tensor)` *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Processed beam scores for each vocabulary token at each generation step. Beam scores consisting of log
-            softmax scores for each vocabulary token and sum of log softmax of previously generated tokens in this
-            beam. Tuple of `tf.Tensor` with up to `max_new_tokens` elements (one element for each generated token),
-            with each tensor of shape `(batch_size*num_beams*num_return_sequences, config.vocab_size)`.
-        beam_indices (`tf.Tensor`, *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Beam indices of generated token id at each generation step. `tf.Tensor` of shape
-            `(batch_size*num_return_sequences, sequence_length)`.
-        attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size*num_beams, num_heads, generated_length, sequence_length)`.
-        hidden_states (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.
-    """
-
-    sequences: tf.Tensor = None
-    sequences_scores: Optional[tf.Tensor] = None
-    scores: Optional[Tuple[tf.Tensor]] = None
-    beam_indices: Optional[tf.Tensor] = None
-    attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    hidden_states: Optional[Tuple[Tuple[tf.Tensor]]] = None
-
-
-@dataclass
-class TFBeamSearchEncoderDecoderOutput(ModelOutput):
-    """
-    Base class for outputs of encoder-decoder generation models using beam search. Hidden states and attention weights
-    of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the encoder_hidden_states
-    attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
-
-    Args:
-        sequences (`tf.Tensor` of shape `(batch_size*num_return_sequences, sequence_length)`):
-            The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter
-            if all batches finished early due to the `eos_token_id`.
-        sequences_scores (`tf.Tensor` of shape `(batch_size*num_return_sequences)`, *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Final beam scores of the generated `sequences`.
-        scores (`tuple(tf.Tensor)` *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Processed beam scores for each vocabulary token at each generation step. Beam scores consisting of log
-            softmax scores for each vocabulary token and sum of log softmax of previously generated tokens in this
-            beam. `Tuple of `tf.Tensor` with up to `max_new_tokens` elements (one element for each generated token),
-            with each tensor of shape `(batch_size*num_beams, config.vocab_size)`.
-        beam_indices (`tf.Tensor`, *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Beam indices of generated token id at each generation step. `tf.Tensor` of shape
-            `(batch_size*num_return_sequences, sequence_length)`.
-        encoder_attentions (`tuple(tf.Tensor)`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple of `tf.Tensor` (one for each layer of the decoder) of shape `(batch_size, num_heads, sequence_length,
-            sequence_length)`.
-        encoder_hidden_states (`tuple(tf.Tensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple of `tf.Tensor` (one for the output of the embeddings + one for the output of each layer) of shape
-            `(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)`.
-        decoder_attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size*num_beams*num_return_sequences, num_heads, generated_length,
-            sequence_length)`.
-        cross_attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, num_heads, generated_length, sequence_length)`.
-        decoder_hidden_states (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.
-    """
-
-    sequences: tf.Tensor = None
-    sequences_scores: Optional[tf.Tensor] = None
-    scores: Optional[Tuple[tf.Tensor]] = None
-    beam_indices: Optional[tf.Tensor] = None
-    encoder_attentions: Optional[Tuple[tf.Tensor]] = None
-    encoder_hidden_states: Optional[Tuple[tf.Tensor]] = None
-    decoder_attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    cross_attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    decoder_hidden_states: Optional[Tuple[Tuple[tf.Tensor]]] = None
-
-
-@dataclass
-class TFBeamSampleDecoderOnlyOutput(ModelOutput):
-    """
-    Base class for outputs of decoder-only generation models using beam sample.
-
-    Args:
-        sequences (`tf.Tensor` of shape `(batch_size*num_return_sequences, sequence_length)`):
-            The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter
-            if all batches finished early due to the `eos_token_id`.
-        sequences_scores (`tf.Tensor` of shape `(batch_size * num_return_sequence)`, *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Final beam scores of the generated `sequences`.
-        scores (`tuple(tf.Tensor)` *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Processed beam scores for each vocabulary token at each generation step. Beam scores consisting of log
-            softmax scores for each vocabulary token and sum of log softmax of previously generated tokens in this
-            beam. Tuple of `tf.Tensor` with up to `max_new_tokens` elements (one element for each generated token),
-            with each tensor of shape `(batch_size*num_beams*num_return_sequences, config.vocab_size)`.
-        beam_indices (`tf.Tensor`, *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Beam indices of generated token id at each generation step. `tf.Tensor` of shape
-            `(batch_size*num_return_sequences, sequence_length)`.
-        attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size*num_beams, num_heads, generated_length, sequence_length)`.
-        hidden_states (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size*num_beams, generated_length, hidden_size)`.
-    """
-
-    sequences: tf.Tensor = None
-    sequences_scores: Optional[tf.Tensor] = None
-    scores: Optional[Tuple[tf.Tensor]] = None
-    beam_indices: Optional[tf.Tensor] = None
-    attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    hidden_states: Optional[Tuple[Tuple[tf.Tensor]]] = None
-
-
-@dataclass
-class TFBeamSampleEncoderDecoderOutput(ModelOutput):
-    """
-    Base class for outputs of encoder-decoder generation models using beam sampling. Hidden states and attention
-    weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the
-    encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
-
-    Args:
-        sequences (`tf.Tensor` of shape `(batch_size*num_beams, sequence_length)`):
-            The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter
-            if all batches finished early due to the `eos_token_id`.
-        sequences_scores (`tf.Tensor` of shape `(batch_size * num_return_sequence)`, *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Final beam scores of the generated `sequences`.
-        scores (`tuple(tf.Tensor)` *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Processed beam scores for each vocabulary token at each generation step. Beam scores consisting of log
-            softmax scores for each vocabulary token and sum of log softmax of previously generated tokens in this
-            beam. Tuple of `tf.Tensor` with up to `max_new_tokens` elements (one element for each generated token),
-            with each tensor of shape `(batch_size*num_beams, config.vocab_size)`.
-        beam_indices (`tf.Tensor`, *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Beam indices of generated token id at each generation step. `tf.Tensor` of shape
-            `(batch_size*num_return_sequences, sequence_length)`.
-        encoder_attentions (`tuple(tf.Tensor)`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple of `tf.Tensor` (one for each layer of the decoder) of shape `(batch_size, num_heads, sequence_length,
-            sequence_length)`.
-        encoder_hidden_states (`tuple(tf.Tensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple of `tf.Tensor` (one for the output of the embeddings + one for the output of each layer) of shape
-            `(batch_size*num_beams, sequence_length, hidden_size)`.
-        decoder_attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size*num_beams, num_heads, generated_length, sequence_length)`.
-        cross_attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, num_heads, generated_length, sequence_length)`.
-        decoder_hidden_states (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size*num_beams, generated_length, hidden_size)`.
-    """
-
-    sequences: tf.Tensor = None
-    sequences_scores: Optional[tf.Tensor] = None
-    scores: Optional[Tuple[tf.Tensor]] = None
-    beam_indices: Optional[tf.Tensor] = None
-    encoder_attentions: Optional[Tuple[tf.Tensor]] = None
-    encoder_hidden_states: Optional[Tuple[tf.Tensor]] = None
-    decoder_attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    cross_attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    decoder_hidden_states: Optional[Tuple[Tuple[tf.Tensor]]] = None
-
-
-@dataclass
-class TFContrastiveSearchDecoderOnlyOutput(ModelOutput):
-    """
-    Base class for outputs of decoder-only generation models using contrastive search.
-
-    Args:
-        sequences (`tf.Tensor` of shape `(batch_size, sequence_length)`):
-            The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter
-            if all batches finished early due to the `eos_token_id`.
-        scores (`tuple(tf.Tensor)` *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax)
-            at each generation step. Tuple of `tf.Tensor` with up to `max_new_tokens` elements (one element for each
-            generated token), with each tensor of shape `(batch_size, config.vocab_size)`.
-        attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, num_heads, generated_length, sequence_length)`.
-        hidden_states (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, generated_length, hidden_size)`.
-    """
-
-    sequences: tf.Tensor = None
-    scores: Optional[Tuple[tf.Tensor]] = None
-    attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    hidden_states: Optional[Tuple[Tuple[tf.Tensor]]] = None
-
-
-@dataclass
-class TFContrastiveSearchEncoderDecoderOutput(ModelOutput):
-    """
-    Base class for outputs of encoder-decoder generation models using contrastive search. Hidden states and attention
-    weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the
-    encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
-
-    Args:
-        sequences (`tf.Tensor` of shape `(batch_size, sequence_length)`):
-            The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter
-            if all batches finished early due to the `eos_token_id`.
-        scores (`tuple(tf.Tensor)` *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`):
-            Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax)
-            at each generation step. Tuple of `tf.Tensor` with up to `max_new_tokens` elements (one element for each
-            generated token), with each tensor of shape `(batch_size, config.vocab_size)`.
-        encoder_attentions (`tuple(tf.Tensor)`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple of `tf.Tensor` (one for each layer of the decoder) of shape `(batch_size, num_heads, sequence_length,
-            sequence_length)`.
-        encoder_hidden_states (`tuple(tf.Tensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple of `tf.Tensor` (one for the output of the embeddings + one for the output of each layer) of shape
-            `(batch_size, sequence_length, hidden_size)`.
-        decoder_attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, num_heads, generated_length, sequence_length)`.
-        cross_attentions (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, num_heads, generated_length, sequence_length)`.
-        decoder_hidden_states (`tuple(tuple(tf.Tensor))`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
-            `tf.Tensor` of shape `(batch_size, generated_length, hidden_size)`.
-    """
-
-    sequences: tf.Tensor = None
-    scores: Optional[Tuple[tf.Tensor]] = None
-    encoder_attentions: Optional[Tuple[tf.Tensor]] = None
-    encoder_hidden_states: Optional[Tuple[tf.Tensor]] = None
-    decoder_attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    cross_attentions: Optional[Tuple[Tuple[tf.Tensor]]] = None
-    decoder_hidden_states: Optional[Tuple[Tuple[tf.Tensor]]] = None
-
-
-TFGreedySearchOutput = Union[TFGreedySearchEncoderDecoderOutput, TFGreedySearchDecoderOnlyOutput]
-TFSampleOutput = Union[TFSampleEncoderDecoderOutput, TFSampleDecoderOnlyOutput]
-TFBeamSearchOutput = Union[TFBeamSearchEncoderDecoderOutput, TFBeamSearchDecoderOnlyOutput]
-TFBeamSampleOutput = Union[TFBeamSampleEncoderDecoderOutput, TFBeamSampleDecoderOnlyOutput]
-TFContrastiveSearchOutput = Union[TFContrastiveSearchEncoderDecoderOutput, TFContrastiveSearchDecoderOnlyOutput]
-TFGenerateOutput = Union[
-    TFGreedySearchOutput, TFSampleOutput, TFBeamSearchOutput, TFBeamSampleOutput, TFContrastiveSearchOutput
-]
-
-
-class TFGenerationMixin:
-    """
-    A class containing all of the functions supporting generation, to be used as a mixin in [`TFPreTrainedModel`].
-
-    The class exposes [`~generation.TFGenerationMixin.generate`], which can be used for:
-        - *greedy decoding* by calling [`~generation.TFGenerationMixin.greedy_search`] if `num_beams=1` and
-          `do_sample=False`
-        - *contrastive search* by calling [`~generation.TFGenerationMixin.contrastive_search`] if `penalty_alpha>0` and
-          `top_k>1`
-        - *multinomial sampling* by calling [`~generation.TFGenerationMixin.sample`] if `num_beams=1` and
-          `do_sample=True`
-        - *beam-search decoding* by calling [`~generation.TFGenerationMixin.beam_search`] if `num_beams>1`
-
-    You do not need to call any of the above methods directly. Pass custom parameter values to 'generate' instead. To
-    learn more about decoding strategies refer to the [text generation strategies guide](../generation_strategies).
-    """
-
-    _seed_generator = None
-
-    @property
-    def seed_generator(self):
-        warnings.warn("`seed_generator` is deprecated and will be removed in a future version.", UserWarning)
-        if self._seed_generator is None:
-            self._seed_generator = tf.random.Generator.from_non_deterministic_state()
-        return self._seed_generator
-
-    supports_xla_generation = True
-
-    def prepare_inputs_for_generation(self, *args, **kwargs):
-        raise NotImplementedError(
-            "A model class needs to define a `prepare_inputs_for_generation` method in order to use `generate`."
-        )
-
-    def compute_transition_scores(
-        self,
-        sequences: tf.Tensor,
-        scores: Tuple[tf.Tensor],
-        beam_indices: Optional[tf.Tensor] = None,
-        normalize_logits: bool = False,
-    ) -> tf.Tensor:
-        """
-        Computes the transition scores of sequences given the generation scores (and beam indices, if beam search was
-        used). This is a convenient method to quicky obtain the scores of the selected tokens at generation time.
-
-        Parameters:
-            sequences (`tf.Tensor`):
-                The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or
-                shorter if all batches finished early due to the `eos_token_id`.
-            scores (`tuple(tf.Tensor)`):
-                Transition scores for each vocabulary token at each generation step. Beam transition scores consisting
-                of log probabilities of tokens conditioned on log softmax of previously generated tokens Tuple of
-                `tf.Tensor` with up to `max_new_tokens` elements (one element for each generated token), with each
-                tensor of shape `(batch_size*num_beams, config.vocab_size)`.
-            beam_indices (`tf.Tensor`, *optional*):
-                Beam indices of generated token id at each generation step. `tf.Tensor` of shape
-                `(batch_size*num_return_sequences, sequence_length)`. Only required if a `num_beams>1` at
-                generate-time.
-            normalize_logits (`bool`, *optional*, defaults to `False`):
-                Whether to normalize the logits (which, for legacy reasons, may be unnormalized).
-
-        Return:
-            `tf.Tensor`: A `tf.Tensor` of shape `(batch_size*num_return_sequences, sequence_length)` containing
-                the transition scores (logits)
-
-        Examples:
-
-        ```python
-        >>> from transformers import GPT2Tokenizer, TFAutoModelForCausalLM
-        >>> import numpy as np
-
-        >>> tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
-        >>> model = TFAutoModelForCausalLM.from_pretrained("gpt2")
-        >>> tokenizer.pad_token_id = tokenizer.eos_token_id
-        >>> inputs = tokenizer(["Today is"], return_tensors="tf")
-
-        >>> # Example 1: Print the scores for each token generated with Greedy Search
-        >>> outputs = model.generate(**inputs, max_new_tokens=5, return_dict_in_generate=True, output_scores=True)
-        >>> transition_scores = model.compute_transition_scores(
-        ...     outputs.sequences, outputs.scores, normalize_logits=True
-        ... )
-        >>> # input_length is the length of the input prompt for decoder-only models, like the GPT family, and 1 for
-        >>> # encoder-decoder models, like BART or T5.
-        >>> input_length = 1 if model.config.is_encoder_decoder else inputs.input_ids.shape[1]
-        >>> generated_tokens = outputs.sequences[:, input_length:]
-        >>> for tok, score in zip(generated_tokens[0], transition_scores[0]):
-        ...     # | token | token string | logits | probability
-        ...     print(f"| {tok:5d} | {tokenizer.decode(tok):8s} | {score.numpy():.3f} | {np.exp(score.numpy()):.2%}")
-        |   262 |  the     | -1.413 | 24.33%
-        |  1110 |  day     | -2.609 | 7.36%
-        |   618 |  when    | -2.009 | 13.41%
-        |   356 |  we      | -1.859 | 15.58%
-        |   460 |  can     | -2.508 | 8.14%
-
-        >>> # Example 2: Reconstruct the sequence scores from Beam Search
-        >>> outputs = model.generate(
-        ...     **inputs,
-        ...     max_new_tokens=5,
-        ...     num_beams=4,
-        ...     num_return_sequences=4,
-        ...     return_dict_in_generate=True,
-        ...     output_scores=True,
-        ... )
-        >>> transition_scores = model.compute_transition_scores(
-        ...     outputs.sequences, outputs.scores, outputs.beam_indices, normalize_logits=False
-        ... )
-        >>> # If you sum the generated tokens' scores and apply the length penalty, you'll get the sequence scores.
-        >>> # Tip: recomputing the scores is only guaranteed to match with `normalize_logits=False`. Depending on the
-        >>> # use case, you might want to recompute it with `normalize_logits=True`.
-        >>> output_length = input_length + np.sum(transition_scores.numpy() < 0, axis=1)
-        >>> length_penalty = model.generation_config.length_penalty
-        >>> reconstructed_scores = np.sum(transition_scores, axis=1) / (output_length**length_penalty)
-        >>> print(np.allclose(outputs.sequences_scores, reconstructed_scores))
-        True
-        ```"""
-        # 1. In absence of `beam_indices`, we can assume that we come from e.g. greedy search, which is equivalent
-        # to a beam search approach were the first (and only) beam is always selected
-        if beam_indices is None:
-            beam_indices = tf.tile(tf.expand_dims(tf.range(scores[0].shape[0]), axis=1), [1, len(scores)])
-
-        # 2. reshape scores as [batch_size, vocab_size, # generation steps] with # generation steps being
-        # seq_len - input_length
-        scores = tf.transpose(tf.reshape(tf.stack(scores), (len(scores), -1)), (1, 0))
-        scores = tf.reshape(scores, (-1, self.config.vocab_size, scores.shape[-1]))
-
-        # 3. Optionally normalize the logits (across the vocab dimension)
-        if normalize_logits:
-            scores = tf.nn.log_softmax(scores, axis=1)
-
-        # 4. cut beam_indices to longest beam length
-        beam_indices_mask = beam_indices < 0
-        max_beam_length = tf.math.reduce_max(
-            tf.math.reduce_sum((1 - tf.cast(beam_indices_mask, dtype=tf.int32)), axis=-1)
-        )
-        beam_indices = beam_indices[:, -max_beam_length:]
-        beam_indices_mask = beam_indices_mask[:, -max_beam_length:]
-
-        # 5. Set indices of beams that finished early to 0; such indices will be masked correctly afterwards
-        beam_indices = tf.where(beam_indices_mask, 0, beam_indices)
-
-        # 6. Define which indices contributed to scores
-        cut_idx = sequences.shape[-1] - max_beam_length
-        token_indices = sequences[:, cut_idx:]
-        gen_step_idx = tf.broadcast_to(tf.range(scores.shape[-1]), token_indices.shape)
-        indices = tf.stack([beam_indices, token_indices, gen_step_idx], axis=-1)
-
-        # 7. Compute scores
-        transition_scores = tf.gather_nd(scores, indices)
-
-        # 8. Mask out transition_scores of beams that stopped early
-        transition_scores = tf.where(beam_indices_mask, 0, transition_scores)
-
-        return transition_scores
-
-    def _validate_model_class(self):
-        """
-        Confirms that the model class is compatible with generation. If not, raises an exception that points to the
-        right class to use.
-        """
-        if not self.can_generate():
-            generate_compatible_mappings = [
-                TF_MODEL_FOR_CAUSAL_LM_MAPPING,
-                TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
-                TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
-                TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
-            ]
-            generate_compatible_classes = set()
-            for model_mapping in generate_compatible_mappings:
-                supported_models = model_mapping.get(type(self.config), default=None)
-                if supported_models is not None:
-                    generate_compatible_classes.add(supported_models.__name__)
-            exception_message = (
-                f"The current model class ({self.__class__.__name__}) is not compatible with `.generate()`, as "
-                "it doesn't have a language model head."
-            )
-            if generate_compatible_classes:
-                exception_message += f" Please use one of the following classes instead: {generate_compatible_classes}"
-            raise TypeError(exception_message)
-
-    def _validate_model_kwargs(self, model_kwargs: Dict[str, Any]):
-        """Validates model kwargs for generation. Generate argument typos will also be caught here."""
-        # Excludes arguments that are handled before calling any model function
-        if self.config.is_encoder_decoder:
-            for key in ["decoder_input_ids"]:
-                model_kwargs.pop(key, None)
-
-        unused_model_args = []
-        model_args = set(inspect.signature(self.prepare_inputs_for_generation).parameters)
-        # `kwargs`/`model_kwargs` is often used to handle optional forward pass inputs like `attention_mask`. If
-        # `prepare_inputs_for_generation` doesn't accept them, then a stricter check can be made ;)
-        if "kwargs" in model_args or "model_kwargs" in model_args:
-            model_args |= set(inspect.signature(self.call).parameters)
-        for key, value in model_kwargs.items():
-            if value is not None and key not in model_args:
-                unused_model_args.append(key)
-
-        if unused_model_args:
-            raise ValueError(
-                f"The following `model_kwargs` are not used by the model: {unused_model_args} (note: typos in the"
-                " generate arguments will also show up in this list)"
-            )
-
-    def generate(
-        self,
-        inputs: Optional[tf.Tensor] = None,
-        generation_config: Optional[GenerationConfig] = None,
-        logits_processor: Optional[TFLogitsProcessorList] = None,
-        seed=None,
-        **kwargs,
-    ) -> Union[TFGenerateOutput, tf.Tensor]:
-        r"""
-        Generates sequences of token ids for models with a language modeling head.
-
-        <Tip warning={true}>
-
-        Most generation-controlling parameters are set in `generation_config` which, if not passed, will be set to the
-        model's default generation configuration. You can override any `generation_config` by passing the corresponding
-        parameters to generate, e.g. `.generate(inputs, num_beams=4, do_sample=True)`.
-
-        For an overview of generation strategies and code examples, check out the [following
-        guide](../generation_strategies).
-
-        </Tip>
-
-        Parameters:
-            inputs (`tf.Tensor` of varying shape depending on the modality, *optional*):
-                The sequence used as a prompt for the generation or as model inputs to the encoder. If `None` the
-                method initializes it with `bos_token_id` and a batch size of 1. For decoder-only models `inputs`
-                should of in the format of `input_ids`. For encoder-decoder models *inputs* can represent any of
-                `input_ids`, `input_values`, `input_features`, or `pixel_values`.
-            generation_config (`~generation.GenerationConfig`, *optional*):
-                The generation configuration to be used as base parametrization for the generation call. `**kwargs`
-                passed to generate matching the attributes of `generation_config` will override them. If
-                `generation_config` is not provided, the default will be used, which had the following loading
-                priority: 1) from the `generation_config.json` model file, if it exists; 2) from the model
-                configuration. Please note that unspecified parameters will inherit [`~generation.GenerationConfig`]'s
-                default values, whose documentation should be checked to parameterize generation.
-            logits_processor (`LogitsProcessorList`, *optional*):
-                Custom logits processors that complement the default logits processors built from arguments and
-                generation config. If a logit processor is passed that is already created with the arguments or a
-                generation config an error is thrown. This feature is intended for advanced users.
-            seed (`List[int]`, *optional*):
-                Random seed to control sampling, containing two integers, used when `do_sample` is `True`. See the
-                `seed` argument from stateless functions in `tf.random`.
-            kwargs (`Dict[str, Any]`, *optional*):
-                Ad hoc parametrization of `generate_config` and/or additional model-specific kwargs that will be
-                forwarded to the `forward` function of the model. If the model is an encoder-decoder model, encoder
-                specific kwargs should not be prefixed and decoder specific kwargs should be prefixed with *decoder_*.
-
-        Return:
-            [`~utils.ModelOutput`] or `tf.Tensor`: A [`~utils.ModelOutput`] (if `return_dict_in_generate=True` or when
-            `config.return_dict_in_generate=True`) or a `tf.Tensor`.
-
-                If the model is *not* an encoder-decoder model (`model.config.is_encoder_decoder=False`), the possible
-                [`~utils.ModelOutput`] types are:
-
-                    - [`~generation.TFGreedySearchDecoderOnlyOutput`],
-                    - [`~generation.TFSampleDecoderOnlyOutput`],
-                    - [`~generation.TFBeamSearchDecoderOnlyOutput`],
-                    - [`~generation.TFBeamSampleDecoderOnlyOutput`]
-
-                If the model is an encoder-decoder model (`model.config.is_encoder_decoder=True`), the possible
-                [`~utils.ModelOutput`] types are:
-
-                    - [`~generation.TFGreedySearchEncoderDecoderOutput`],
-                    - [`~generation.TFSampleEncoderDecoderOutput`],
-                    - [`~generation.TFBeamSearchEncoderDecoderOutput`],
-                    - [`~generation.TFBeamSampleEncoderDecoderOutput`]
-
-        """
-
-        # 1. Handle `generation_config` and kwargs that might update it, and validate the `.generate()` call
-        self._validate_model_class()
-
-        # priority: `generation_config` argument > `model.generation_config` (the default generation config)
-        if generation_config is None:
-            # legacy: users may modify the model configuration to control generation. To trigger this legacy behavior,
-            # two conditions must be met
-            # 1) the generation config must have been created from the model config (`_from_model_config` field);
-            # 2) the generation config must have seen no modification since its creation (the hash is the same).
-            if self.generation_config._from_model_config and self.generation_config._original_object_hash == hash(
-                self.generation_config
-            ):
-                new_generation_config = GenerationConfig.from_model_config(self.config)
-                if new_generation_config != self.generation_config:
-                    warnings.warn(
-                        "You have modified the pretrained model configuration to control generation. This is a"
-                        " deprecated strategy to control generation and will be removed soon, in a future version."
-                        " Please use and modify the model generation configuration (see"
-                        " https://huggingface.co/docs/transformers/generation_strategies#default-text-generation-configuration )"
-                    )
-                    self.generation_config = new_generation_config
-            generation_config = self.generation_config
-
-        generation_config = copy.deepcopy(generation_config)
-        model_kwargs = generation_config.update(**kwargs)  # All unused kwargs must be model kwargs
-        generation_config.validate()
-        self._validate_model_kwargs(model_kwargs.copy())
-
-        # 2. Cast input dtypes to tf.int32 unless they're floats (which happens for some image models)
-        if inputs is not None:
-            if isinstance(inputs, tf.Tensor) and inputs.dtype.is_floating:
-                pass
-            elif isinstance(inputs, np.ndarray) and np.issubdtype(inputs.dtype, np.floating):
-                pass
-            else:
-                inputs = tf.cast(inputs, tf.int32)
-        if model_kwargs.get("attention_mask") is not None:
-            model_kwargs["attention_mask"] = tf.cast(model_kwargs["attention_mask"], tf.int32)
-        if "decoder_input_ids" in model_kwargs:
-            if (
-                isinstance(model_kwargs["decoder_input_ids"], tf.Tensor)
-                and model_kwargs["decoder_input_ids"].dtype.is_floating
-            ):
-                pass
-            elif isinstance(model_kwargs["decoder_input_ids"], np.ndarray) and np.issubdtype(
-                model_kwargs["decoder_input_ids"].dtype, np.floating
-            ):
-                pass
-            else:
-                model_kwargs["decoder_input_ids"] = tf.cast(model_kwargs["decoder_input_ids"], tf.int32)
-
-        # 3. Set generation parameters if not already defined
-        logits_processor = logits_processor if logits_processor is not None else TFLogitsProcessorList()
-
-        if generation_config.pad_token_id is None and generation_config.eos_token_id is not None:
-            if model_kwargs.get("attention_mask") is None:
-                logger.warning(
-                    "The attention mask and the pad token id were not set. As a consequence, you may observe "
-                    "unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results."
-                )
-            eos_token_id = generation_config.eos_token_id
-            if isinstance(eos_token_id, list):
-                eos_token_id = eos_token_id[0]
-            logger.warning(f"Setting `pad_token_id` to `eos_token_id`:{eos_token_id} for open-end generation.")
-            generation_config.pad_token_id = eos_token_id
-
-        use_xla = not tf.executing_eagerly()
-        if use_xla and not self.supports_xla_generation:
-            raise ValueError(
-                "The selected model does not support Graph mode nor XLA generation (e.g. from tf.function())"
-            )
-
-        # 4. Define model inputs
-        inputs_tensor, model_input_name, model_kwargs = self._prepare_model_inputs(
-            inputs, generation_config.bos_token_id, model_kwargs
-        )
-        # inputs_ids now has to be defined and cannot be None anymore
-        batch_size = shape_list(inputs_tensor)[0]
-
-        # 5. Prepare other model kwargs
-        model_kwargs["output_attentions"] = generation_config.output_attentions
-        model_kwargs["output_hidden_states"] = generation_config.output_hidden_states
-        model_kwargs["use_cache"] = generation_config.use_cache
-
-        accepts_attention_mask = "attention_mask" in set(inspect.signature(self.call).parameters.keys())
-        requires_attention_mask = "encoder_outputs" not in model_kwargs
-
-        if model_kwargs.get("attention_mask", None) is None and requires_attention_mask and accepts_attention_mask:
-            model_kwargs["attention_mask"] = self._prepare_attention_mask_for_generation(
-                inputs_tensor, generation_config.pad_token_id, generation_config.eos_token_id
-            )
-
-        # decoder-only models should use left-padding for generation
-        if not self.config.is_encoder_decoder:
-            if generation_config.pad_token_id is not None and tf.math.reduce_any(
-                inputs_tensor[:, -1] == generation_config.pad_token_id
-            ):
-                logger.warning(
-                    "A decoder-only architecture is being used, but right-padding was detected! For correct "
-                    "generation results, please set `padding_side='left'` when initializing the tokenizer."
-                )
-        if self.config.is_encoder_decoder and "encoder_outputs" not in model_kwargs:
-            # if model is encoder decoder encoder_outputs are created and added to `model_kwargs`
-            model_kwargs = self._prepare_encoder_decoder_kwargs_for_generation(
-                inputs_tensor, model_kwargs, model_input_name
-            )
-
-        # 6. Prepare model inputs which will be used for auto-regressive generation
-        if self.config.is_encoder_decoder:
-            input_ids, model_kwargs = self._prepare_decoder_input_ids_for_generation(
-                batch_size=batch_size,
-                model_input_name=model_input_name,
-                model_kwargs=model_kwargs,
-                decoder_start_token_id=generation_config.decoder_start_token_id,
-                bos_token_id=generation_config.bos_token_id,
-            )
-        else:
-            input_ids = inputs_tensor if model_input_name == "input_ids" else model_kwargs.pop("input_ids")
-
-        # 7. Prepare `max_length` depending on other stopping criteria.
-        input_ids_seq_length = shape_list(input_ids)[-1]
-        has_default_max_length = kwargs.get("max_length") is None and generation_config.max_length is not None
-        if has_default_max_length and generation_config.max_new_tokens is None and generation_config.max_length == 20:
-            # 20 is the default max_length of the generation config
-            warnings.warn(
-                f"Using the model-agnostic default `max_length` (={generation_config.max_length}) "
-                "to control the generation length.  recommend setting `max_new_tokens` to control the maximum length of the generation.",
-                UserWarning,
-            )
-        elif generation_config.max_new_tokens is not None:
-            if not has_default_max_length and generation_config.max_length is not None:
-                logger.warning(
-                    f"Both `max_new_tokens` (={generation_config.max_new_tokens}) and `max_length`(="
-                    f"{generation_config.max_length}) seem to have been set. `max_new_tokens` will take precedence. "
-                    "Please refer to the documentation for more information. "
-                    "(https://huggingface.co/docs/transformers/main/en/main_classes/text_generation)"
-                )
-            generation_config.max_length = generation_config.max_new_tokens + input_ids_seq_length
-
-        # If the input length is a tensor (i.e. dynamic length), skip length checks
-        if not isinstance(input_ids_seq_length, tf.Tensor):
-            if (
-                generation_config.min_length is not None
-                and generation_config.min_length > generation_config.max_length
-            ):
-                raise ValueError(
-                    f"Unfeasable length constraints: the minimum length ({generation_config.min_length}) is larger"
-                    f" than the maximum length ({generation_config.max_length})"
-                )
-            if input_ids_seq_length >= generation_config.max_length:
-                input_ids_string = "decoder_input_ids" if self.config.is_encoder_decoder else "input_ids"
-                logger.warning(
-                    f"Input length of {input_ids_string} is {input_ids_seq_length}, but `max_length` is set to"
-                    f" {generation_config.max_length}. This can lead to unexpected behavior. You should consider"
-                    " increasing`max_new_tokens`."
-                )
-
-        # 8. determine generation mode
-        is_contrastive_search_gen_mode = (
-            generation_config.top_k is not None
-            and generation_config.top_k > 1
-            and generation_config.do_sample is False
-            and generation_config.penalty_alpha is not None
-            and generation_config.penalty_alpha > 0
-        )
-        is_greedy_gen_mode = (
-            not is_contrastive_search_gen_mode
-            and (generation_config.num_beams == 1)
-            and generation_config.do_sample is False
-        )
-        is_beam_gen_mode = (
-            not is_contrastive_search_gen_mode
-            and (generation_config.num_beams > 1)
-            and generation_config.do_sample is False
-        )
-        is_sample_gen_mode = (generation_config.num_beams == 1) and generation_config.do_sample is True
-        is_beam_sample_gen_mode = (generation_config.num_beams > 1) and generation_config.do_sample is True
-
-        # 9. prepare distribution pre_processing samplers
-        logits_processor = self._get_logits_processor(
-            generation_config=generation_config,
-            input_ids_seq_length=input_ids_seq_length,
-            logits_processor=logits_processor,
-        )
-
-        # 10. go into different generation modes
-        if is_greedy_gen_mode:
-            if generation_config.num_return_sequences > 1:
-                raise ValueError(
-                    f"num_return_sequences has to be 1, but is {generation_config.num_return_sequences} when doing"
-                    " greedy search."
-                )
-            # 11. run greedy search
-            return self.greedy_search(
-                input_ids,
-                max_length=generation_config.max_length,
-                pad_token_id=generation_config.pad_token_id,
-                eos_token_id=generation_config.eos_token_id,
-                logits_processor=logits_processor,
-                output_scores=generation_config.output_scores,
-                return_dict_in_generate=generation_config.return_dict_in_generate,
-                **model_kwargs,
-            )
-        elif is_contrastive_search_gen_mode:
-            if generation_config.num_return_sequences > 1:
-                raise ValueError(
-                    f"num_return_sequences has to be 1, but is {generation_config.num_return_sequences} when doing"
-                    " contrastive search."
-                )
-            # 11. run contrastive search
-            return self.contrastive_search(
-                input_ids,
-                top_k=generation_config.top_k,
-                penalty_alpha=generation_config.penalty_alpha,
-                logits_processor=logits_processor,
-                max_length=generation_config.max_length,
-                pad_token_id=generation_config.pad_token_id,
-                eos_token_id=generation_config.eos_token_id,
-                output_scores=generation_config.output_scores,
-                return_dict_in_generate=generation_config.return_dict_in_generate,
-                **model_kwargs,
-            )
-        elif is_sample_gen_mode:
-            # 11. prepare logits warper
-            logits_warper = self._get_logits_warper(generation_config=generation_config)
-
-            # 12. expand input_ids with `num_return_sequences` additional sequences per batch
-            input_ids, model_kwargs = self._expand_inputs_for_generation(
-                input_ids=input_ids,
-                expand_size=generation_config.num_return_sequences,
-                is_encoder_decoder=self.config.is_encoder_decoder,
-                **model_kwargs,
-            )
-
-            # 13. run sample
-            return self.sample(
-                input_ids,
-                logits_processor=logits_processor,
-                logits_warper=logits_warper,
-                max_length=generation_config.max_length,
-                pad_token_id=generation_config.pad_token_id,
-                eos_token_id=generation_config.eos_token_id,
-                seed=seed,
-                output_scores=generation_config.output_scores,
-                return_dict_in_generate=generation_config.return_dict_in_generate,
-                **model_kwargs,
-            )
-
-        elif is_beam_gen_mode:
-            if generation_config.num_beams < generation_config.num_return_sequences:
-                raise ValueError(
-                    "Beam search decoding cannot return more sequences than it has beams. Please set num_beams >="
-                    f" num_return_sequences, got {generation_config.num_beams} and"
-                    f" {generation_config.num_return_sequences} (respectivelly)"
-                )
-
-            # 11. broadcast inputs to the desired number of beams
-            input_ids, model_kwargs = self._expand_inputs_for_generation(
-                input_ids=input_ids,
-                expand_size=generation_config.num_beams,
-                is_encoder_decoder=self.config.is_encoder_decoder,
-                expand_in_new_axis=True,
-                **model_kwargs,
-            )
-
-            # 12. run beam search
-            return self.beam_search(
-                input_ids,
-                max_length=generation_config.max_length,
-                pad_token_id=generation_config.pad_token_id,
-                eos_token_id=generation_config.eos_token_id,
-                length_penalty=generation_config.length_penalty,
-                early_stopping=generation_config.early_stopping,
-                logits_processor=logits_processor,
-                output_scores=generation_config.output_scores,
-                return_dict_in_generate=generation_config.return_dict_in_generate,
-                num_return_sequences=generation_config.num_return_sequences,
-                **model_kwargs,
-            )
-
-        elif is_beam_sample_gen_mode:
-            if generation_config.num_beams < generation_config.num_return_sequences:
-                raise ValueError(
-                    "Beam search decoding cannot return more sequences than it has beams. Please set num_beams >="
-                    f" num_return_sequences, got {generation_config.num_beams} and"
-                    f" {generation_config.num_return_sequences} (respectivelly)"
-                )
-
-            # 11. prepare logits warper
-            logits_warper = self._get_logits_warper(generation_config=generation_config)
-
-            # 12. broadcast inputs to the desired number of beams
-            input_ids, model_kwargs = self._expand_inputs_for_generation(
-                input_ids=input_ids,
-                expand_size=generation_config.num_beams,
-                is_encoder_decoder=self.config.is_encoder_decoder,
-                expand_in_new_axis=True,
-                **model_kwargs,
-            )
-
-            # 13. run beam sample (beam search with sampling)
-            return self.beam_search(
-                input_ids,
-                do_sample=True,
-                max_length=generation_config.max_length,
-                pad_token_id=generation_config.pad_token_id,
-                eos_token_id=generation_config.eos_token_id,
-                length_penalty=generation_config.length_penalty,
-                early_stopping=generation_config.early_stopping,
-                logits_processor=logits_processor,
-                logits_warper=logits_warper,
-                output_scores=generation_config.output_scores,
-                return_dict_in_generate=generation_config.return_dict_in_generate,
-                num_return_sequences=generation_config.num_return_sequences,
-                **model_kwargs,
-            )
-
-    def _prepare_attention_mask_for_generation(
-        self,
-        inputs: tf.Tensor,
-        pad_token_id: Optional[int],
-        eos_token_id: Optional[int],
-    ) -> tf.Tensor:
-        is_input_ids = len(inputs.shape) == 2 and inputs.dtype in (tf.int32, tf.int64)
-        is_pad_token_in_inputs = (pad_token_id is not None) and tf.math.reduce_any(inputs == pad_token_id)
-        is_pad_token_not_equal_to_eos_token_id = (eos_token_id is None) or (pad_token_id != eos_token_id)
-
-        # Check if input is input_ids and padded -> only then is attention_mask defined
-        if is_input_ids and is_pad_token_in_inputs and is_pad_token_not_equal_to_eos_token_id:
-            return tf.cast(tf.math.not_equal(inputs, pad_token_id), dtype=tf.int32)
-        else:
-            return tf.ones(inputs.shape[:2], dtype=tf.int32)
-
-    def _prepare_encoder_decoder_kwargs_for_generation(
-        self, inputs_tensor: tf.Tensor, model_kwargs, model_input_name: Optional[str] = None
-    ) -> Dict[str, Any]:
-        # 1. get encoder and store encoder outputs
-        encoder = self.get_encoder()
-
-        # 2. prepare encoder args and encoder kwargs from model kwargs
-        irrelevant_prefix = ["decoder_", "cross_attn", "use_cache"]
-        encoder_kwargs = {
-            argument: value
-            for argument, value in model_kwargs.items()
-            if not any(argument.startswith(p) for p in irrelevant_prefix)
-        }
-        encoder_signature = set(inspect.signature(encoder.call).parameters)
-        encoder_accepts_wildcard = "kwargs" in encoder_signature or "model_kwargs" in encoder_signature
-        if not encoder_accepts_wildcard:
-            encoder_kwargs = {
-                argument: value for argument, value in encoder_kwargs.items() if argument in encoder_signature
-            }
-
-        # 3. vision models don't use `attention_mask`.
-        encoder_kwargs["return_dict"] = True
-        encoder_kwargs[model_input_name] = inputs_tensor
-        if model_input_name != self.main_input_name:  # in Keras, the first input must always be passed
-            encoder_kwargs[self.main_input_name] = None
-        encoder_outputs = encoder(**encoder_kwargs)
-        model_kwargs["encoder_outputs"] = encoder_outputs
-
-        return model_kwargs
-
-    def _prepare_decoder_input_ids_for_generation(
-        self,
-        batch_size: int,
-        model_input_name: str,
-        model_kwargs: Dict[str, tf.Tensor],
-        decoder_start_token_id: int = None,
-        bos_token_id: int = None,
-    ) -> Tuple[tf.Tensor, Dict[str, tf.Tensor]]:
-        """Prepares `decoder_input_ids` for generation with encoder-decoder models"""
-        # 1. Check whether the user has defined `decoder_input_ids` manually. To facilitate in terms of input naming,
-        # we also allow the user to pass it under `input_ids`, if the encoder does not use it as the main input.
-        if model_kwargs is not None and "decoder_input_ids" in model_kwargs:
-            decoder_input_ids = model_kwargs.pop("decoder_input_ids")
-        elif "input_ids" in model_kwargs and model_input_name != "input_ids":
-            decoder_input_ids = model_kwargs.pop("input_ids")
-        else:
-            decoder_input_ids = None
-
-        # 2. Encoder-decoder models expect the `decoder_input_ids` to start with a special token. Let's ensure that.
-        decoder_start_token_id = self._get_decoder_start_token_id(decoder_start_token_id, bos_token_id)
-        decoder_input_ids_start = tf.ones((batch_size, 1), dtype=tf.int32) * decoder_start_token_id
-
-        # no user input -> use decoder_start_token_id as decoder_input_ids
-        if decoder_input_ids is None:
-            decoder_input_ids = decoder_input_ids_start
-        # user input but doesn't start with decoder_start_token_id -> prepend decoder_start_token_id (and adjust
-        # decoder_attention_mask if provided)
-        elif tf.reduce_all(decoder_input_ids[:, 0] != decoder_start_token_id):
-            decoder_input_ids = tf.concat([decoder_input_ids_start, decoder_input_ids], axis=-1)
-            if "decoder_attention_mask" in model_kwargs:
-                decoder_attention_mask = model_kwargs["decoder_attention_mask"]
-                decoder_attention_mask = tf.concat(
-                    (tf.ones_like(decoder_attention_mask)[:, :1], decoder_attention_mask),
-                    axis=-1,
-                )
-                model_kwargs["decoder_attention_mask"] = decoder_attention_mask
-
-        return decoder_input_ids, model_kwargs
-
-    def _get_decoder_start_token_id(self, decoder_start_token_id: int = None, bos_token_id: int = None) -> int:
-        # retrieve decoder_start_token_id for encoder-decoder models
-        # fall back to bos_token_id if necessary
-        decoder_start_token_id = (
-            decoder_start_token_id
-            if decoder_start_token_id is not None
-            else self.generation_config.decoder_start_token_id
-        )
-        bos_token_id = bos_token_id if bos_token_id is not None else self.generation_config.bos_token_id
-
-        if decoder_start_token_id is not None:
-            return decoder_start_token_id
-        elif bos_token_id is not None:
-            return bos_token_id
-        raise ValueError(
-            "`decoder_start_token_id` or `bos_token_id` has to be defined for encoder-decoder generation."
-        )
-
-    @staticmethod
-    def _expand_inputs_for_generation(
-        expand_size: int = 1,
-        is_encoder_decoder: bool = False,
-        input_ids: Optional[tf.Tensor] = None,
-        expand_in_new_axis: bool = False,
-        **model_kwargs,
-    ) -> Tuple[tf.Tensor, Dict[str, Any]]:
-        """
-        Expands tensors from [batch_size, ...] to [batch_size * expand_size, ...] or [batch_size, expand_size, ...],
-        depending on `expand_in_new_axis`. Beam-based approaches expect this function to be used with
-        `expand_in_new_axis=True`
-        """
-
-        def _expand_tensor(tensor: tf.Tensor):
-            if expand_in_new_axis:
-                shape = shape_list(tensor)
-                return tf.broadcast_to(tensor[:, None], (shape[0], expand_size) + tuple(shape[1:]))
-            else:
-                return tf.repeat(tensor, expand_size, axis=0)
-
-        def _expand_dict_for_generation(dict_to_expand):
-            for key in dict_to_expand:
-                if dict_to_expand[key] is not None and isinstance(dict_to_expand[key], tf.Tensor):
-                    dict_to_expand[key] = _expand_tensor(dict_to_expand[key])
-            return dict_to_expand
-
-        if input_ids is not None:
-            input_ids = _expand_tensor(input_ids)
-
-        model_kwargs = _expand_dict_for_generation(model_kwargs)
-
-        if is_encoder_decoder:
-            if model_kwargs.get("encoder_outputs") is None:
-                raise ValueError("If `is_encoder_decoder` is True, make sure that `encoder_outputs` is defined.")
-            model_kwargs["encoder_outputs"] = _expand_dict_for_generation(model_kwargs["encoder_outputs"])
-
-        return input_ids, model_kwargs
-
-    def _prepare_model_inputs(
-        self,
-        inputs: Optional[tf.Tensor] = None,
-        bos_token_id: Optional[int] = None,
-        model_kwargs: Optional[Dict[str, tf.Tensor]] = None,
-    ) -> Tuple[tf.Tensor, Optional[str], Dict[str, tf.Tensor]]:
-        """
-        This function extracts the model-specific `inputs` for generation.
-        """
-        # 1. retrieve all kwargs that are non-None or non-model input related.
-        # some encoder-decoder models have different names for model and encoder
-        if (
-            self.config.is_encoder_decoder
-            and hasattr(self, "encoder")
-            and hasattr(self.encoder, "main_input_name")
-            and self.encoder.main_input_name != self.main_input_name
-        ):
-            input_name = self.encoder.main_input_name
-        else:
-            input_name = self.main_input_name
-
-        model_kwargs = {k: v for k, v in model_kwargs.items() if v is not None or k != input_name}
-
-        # 2. check whether model_input_name is passed as kwarg
-        # if yes and `inputs` is None use kwarg inputs
-        inputs_kwarg = model_kwargs.pop(input_name, None)
-        if inputs_kwarg is not None and inputs is not None:
-            raise ValueError(
-                f"`inputs`: {inputs}` were passed alongside {input_name} which is not allowed."
-                f"Make sure to either pass {inputs} or {input_name}=..."
-            )
-        elif inputs_kwarg is not None:
-            inputs = inputs_kwarg
-
-        # 3. In the presence of `inputs_embeds` for text models:
-        # - decoder-only models should complain if the user attempts to pass `inputs_embeds`, but the model
-        # doesn't have its forwarding implemented. `inputs_embeds` is kept in `model_kwargs` and can coexist with
-        # input_ids (`inputs_embeds` will be used in the 1st generation step, as opposed to `input_ids`)
-        # - encoder-decoder models should complain if the user attempts to pass `inputs_embeds` and `input_ids`, and
-        # pull the former to inputs. It will be used in place of `input_ids` to get the encoder hidden states.
-        if input_name == "input_ids" and "inputs_embeds" in model_kwargs:
-            if not self.config.is_encoder_decoder:
-                has_inputs_embeds_forwarding = "inputs_embeds" in set(
-                    inspect.signature(self.prepare_inputs_for_generation).parameters.keys()
-                )
-                if not has_inputs_embeds_forwarding:
-                    raise ValueError(
-                        f"You passed `inputs_embeds` to `.generate()`, but the model class {self.__class__.__name__} "
-                        "doesn't have its forwarding implemented. See the GPT2 implementation for an example "
-                        "(https://github.com/huggingface/transformers/pull/21405), and feel free to open a PR with it!"
-                    )
-                # In this case, `input_ids` is moved to the `model_kwargs`, so a few automations (like the creation of
-                # the attention mask) can rely on the actual model input.
-                model_kwargs["input_ids"] = self._maybe_initialize_input_ids_for_generation(
-                    inputs, bos_token_id, model_kwargs=model_kwargs
-                )
-            else:
-                if inputs is not None:
-                    raise ValueError("You passed `inputs_embeds` and `input_ids` to `.generate()`. Please pick one.")
-            inputs, input_name = model_kwargs["inputs_embeds"], "inputs_embeds"
-
-        # 4. if `inputs` is still None, try to create `input_ids` from BOS token
-        inputs = self._maybe_initialize_input_ids_for_generation(inputs, bos_token_id, model_kwargs)
-
-        return inputs, input_name, model_kwargs
-
-    def _maybe_initialize_input_ids_for_generation(
-        self,
-        inputs: Optional[tf.Tensor] = None,
-        bos_token_id: Optional[int] = None,
-        model_kwargs: Optional[Dict[str, tf.Tensor]] = None,
-    ) -> tf.Tensor:
-        """Initializes input ids for generation, if necessary."""
-        if inputs is not None:
-            return inputs
-
-        encoder_outputs = model_kwargs.get("encoder_outputs")
-        if self.config.is_encoder_decoder and encoder_outputs is not None:
-            # make dummy input_ids with value -100, as a sanity check ensuring that they won't be used for encoding
-            shape = encoder_outputs.last_hidden_state.shape[:-1]
-            return tf.ones(shape, dtype=tf.int32) * -100
-
-        if bos_token_id is None:
-            raise ValueError("`bos_token_id` has to be defined when no `input_ids` are provided.")
-
-        # If there is some tensor in `model_kwargs`, we can infer the batch size from it. This is helpful with
-        # soft-prompting or in multimodal implementations built on top of decoder-only language models.
-        batch_size = 1
-        for value in model_kwargs.values():
-            if isinstance(value, tf.Tensor):
-                batch_size = value.shape[0]
-                break
-        return tf.ones((batch_size, 1), dtype=tf.int32) * bos_token_id
-
-    @staticmethod
-    def _extract_past_from_model_output(outputs: ModelOutput):
-        past_key_values = None
-        if "past_key_values" in outputs:
-            past_key_values = outputs.past_key_values
-        elif "mems" in outputs:
-            past_key_values = outputs.mems
-        elif "past_buckets_states" in outputs:
-            past_key_values = outputs.past_buckets_states
-        return past_key_values
-
-    def _update_model_kwargs_for_generation(
-        self, outputs: ModelOutput, model_kwargs: Dict[str, Any], is_encoder_decoder: bool = False
-    ) -> Dict[str, Any]:
-        # update past_key_values
-        model_kwargs["past_key_values"] = self._extract_past_from_model_output(outputs)
-
-        # update attention mask
-        if not is_encoder_decoder:
-            if "attention_mask" in model_kwargs:
-                attention_mask = model_kwargs["attention_mask"]
-                model_kwargs["attention_mask"] = tf.concat(
-                    [attention_mask, tf.ones((shape_list(attention_mask)[0], 1), dtype=tf.int32)], axis=-1
-                )
-
-        return model_kwargs
-
-    def _update_model_kwargs_for_xla_generation(
-        self,
-        model_outputs: ModelOutput,
-        model_kwargs: Dict[str, Any],
-        cur_len: int,
-        max_length: int,
-        batch_size: int,
-        is_encoder_decoder: bool = False,
-        batch_axis: int = 0,
-    ):
-        def _initialize_attention(model_kwargs, num_padding_values, is_encoder_decoder):
-            """initializes the appropriate attention mask -- encoder-decoder models use `decoder_attention_mask`"""
-            if is_encoder_decoder:
-                # One 1 for decoder_start_token_id, 0s for the currently-unfilled locations in the past_key_values tensor,
-                # 1s for the actual input_ids
-                decoder_attention_mask = tf.concat(
-                    [
-                        tf.ones((batch_size, 1), dtype=tf.int32),
-                        tf.zeros((batch_size, num_padding_values), dtype=tf.int32),
-                        tf.ones((batch_size, 1), dtype=tf.int32),
-                    ],
-                    axis=1,
-                )
-                mask = {"decoder_attention_mask": decoder_attention_mask}
-            else:
-                attention_mask = model_kwargs.pop("attention_mask")
-                # 0s for the currently-unfilled locations in the past_key_values tensor, 1s for the actual input_ids
-                attention_mask = tf.concat(
-                    [
-                        attention_mask,
-                        tf.zeros((batch_size, num_padding_values), dtype=attention_mask.dtype),
-                        tf.ones((batch_size, 1), dtype=attention_mask.dtype),
-                    ],
-                    axis=1,
-                )
-                mask = {"attention_mask": attention_mask}
-            return mask
-
-        def _update_attention(model_kwargs, new_past_index, is_encoder_decoder):
-            """updates the appropriate attention mask -- encoder-decoder models use `decoder_attention_mask`"""
-            update_start = tf.constant([0, 1], dtype=tf.int32) * new_past_index
-            if is_encoder_decoder:
-                decoder_attention_mask = model_kwargs.pop("decoder_attention_mask")
-                decoder_attention_mask_update_slice = tf.ones((batch_size, 1), dtype=decoder_attention_mask.dtype)
-                decoder_attention_mask = dynamic_update_slice(
-                    decoder_attention_mask, decoder_attention_mask_update_slice, update_start
-                )
-                mask = {"decoder_attention_mask": decoder_attention_mask}
-            else:
-                attention_mask = model_kwargs.pop("attention_mask")
-                attention_mask_update_slice = tf.ones((batch_size, 1), dtype=attention_mask.dtype)
-                attention_mask = dynamic_update_slice(attention_mask, attention_mask_update_slice, update_start)
-                mask = {"attention_mask": attention_mask}
-            return mask
-
-        def _initialize_past(past_key_values, num_padding_values, batch_axis):
-            """initialize past_key_values with zeros -- the structure depends on `batch_axis`"""
-            if batch_axis == 0:
-                padding_values = tf.constant([[0, 0], [0, 0], [0, num_padding_values], [0, 0]], dtype=tf.int32)
-                new_past = ()
-                for past_layer in past_key_values:
-                    new_past_layer = list(past_layer)
-                    for i in range(len(new_past_layer[:2])):
-                        new_past_layer[i] = tf.pad(past_layer[i], padding_values)
-                    new_past += (tuple(new_past_layer),)
-            else:
-                padding_values = tf.scatter_nd(indices=[[3, 1]], updates=[num_padding_values], shape=(5, 2))
-                new_past = list(past_key_values)
-                for i in range(len(past_key_values)):
-                    new_past[i] = tf.pad(past_key_values[i], padding_values)
-            return new_past
-
-        def _update_past(past_key_values, new_past_index, batch_axis):
-            if batch_axis == 0:
-                slice_start_base = tf.constant([0, 0, 1, 0])
-                new_past = ()
-                for past_layer in past_key_values:
-                    new_past_layer = list(past_layer)
-                    for i in range(len(new_past_layer[:2])):
-                        update_slice = past_layer[i][:, :, -1:]
-                        # Write the last slice to the first open location in the padded past_key_values array
-                        # and then truncate the last slice off the array
-                        new_past_layer[i] = dynamic_update_slice(
-                            past_layer[i][:, :, :-1], update_slice, slice_start_base * new_past_index
-                        )
-                    new_past += (tuple(new_past_layer),)
-            else:
-                slice_start_base = tf.constant([0, 0, 0, 1, 0])
-                new_past = [None for _ in range(len(past_key_values))]
-                for i in range(len(past_key_values)):
-                    update_slice = past_key_values[i][:, :, :, -1:]
-                    # Write the last slice to the first open location in the padded past_key_values array
-                    # and then truncate the last slice off the array
-                    new_past[i] = dynamic_update_slice(
-                        past_key_values[i][:, :, :, :-1], update_slice, slice_start_base * new_past_index
-                    )
-            return new_past
-
-        past_key_values = self._extract_past_from_model_output(model_outputs)
-        if past_key_values is None:
-            raise ValueError(
-                "No known `past_key_values variable` found in model outputs (model outputs keys:"
-                f" {list(model_outputs.keys())})"
-            )
-        is_past_initialized = model_kwargs.pop("past_key_values", None) is not None
-
-        if not is_past_initialized:
-            # The padded version of `past_key_values` has a length of `max_length - 1`, as `past_key_values` holds information relative to
-            # previous autoregressive generation steps (step 0 has no past_key_values, step 1 has 1 past_key_values value, ..., the last step
-            # has `max_length - 1` past_key_values values).
-            num_padding_values = max_length - cur_len - 1
-            mask = _initialize_attention(model_kwargs, num_padding_values, is_encoder_decoder)
-            new_past = _initialize_past(past_key_values, num_padding_values, batch_axis)
-        else:
-            # The new index of past_key_values to be filled corresponds to the current length of the sequence, with two
-            # subtractions: -1 because past_key_values holds information regarding previous generation steps (read comment above)
-            # and -1 again because in an array the index is the length of the array minus 1.
-            new_past_index = cur_len - 2
-            mask = _update_attention(model_kwargs, new_past_index, is_encoder_decoder)
-            new_past = _update_past(past_key_values, new_past_index, batch_axis)
-
-        # sets the updated variables (mask and past_key_values)
-        model_kwargs.update(mask)
-        model_kwargs["past_key_values"] = tuple(new_past)
-
-        return model_kwargs
-
-    def _get_logits_warper(
-        self,
-        generation_config: GenerationConfig,
-    ) -> TFLogitsProcessorList:
-        """
-        This class returns a [`TFLogitsProcessorList`] list object that contains all relevant [`TFLogitsWarper`]
-        instances used for multinomial sampling.
-        """
-
-        # instantiate warpers list
-        warpers = TFLogitsProcessorList()
-
-        # the following idea is largely copied from this PR: https://github.com/huggingface/transformers/pull/5420/files
-        # all samplers can be found in `generation_utils_samplers.py`
-        if generation_config.temperature is not None and generation_config.temperature != 1.0:
-            warpers.append(TFTemperatureLogitsWarper(generation_config.temperature))
-        if generation_config.top_k is not None and generation_config.top_k != 0:
-            warpers.append(TFTopKLogitsWarper(top_k=generation_config.top_k, min_tokens_to_keep=1))
-        if generation_config.top_p is not None and generation_config.top_p < 1.0:
-            warpers.append(TFTopPLogitsWarper(top_p=generation_config.top_p, min_tokens_to_keep=1))
-        return warpers
-
-    def _get_logits_processor(
-        self,
-        generation_config: GenerationConfig,
-        input_ids_seq_length: int,
-        logits_processor: Optional[TFLogitsProcessorList],
-    ) -> TFLogitsProcessorList:
-        """
-        This class returns a [`TFLogitsProcessorList`] list object that contains all relevant [`TFLogitsProcessor`]
-        instances used to modify the scores of the language model head.
-        """
-        processors = TFLogitsProcessorList()
-
-        # instantiate processors list
-        if generation_config.repetition_penalty is not None and generation_config.repetition_penalty != 1.0:
-            processors.append(TFRepetitionPenaltyLogitsProcessor(penalty=generation_config.repetition_penalty))
-        if generation_config.no_repeat_ngram_size is not None and generation_config.no_repeat_ngram_size > 0:
-            processors.append(TFNoRepeatNGramLogitsProcessor(generation_config.no_repeat_ngram_size))
-        if generation_config.bad_words_ids is not None:
-            processors.append(
-                TFNoBadWordsLogitsProcessor(generation_config.bad_words_ids, generation_config.eos_token_id)
-            )
-        if (
-            generation_config.min_length is not None
-            and generation_config.eos_token_id is not None
-            and generation_config.min_length > 0
-        ):
-            processors.append(TFMinLengthLogitsProcessor(generation_config.min_length, generation_config.eos_token_id))
-        if generation_config.forced_bos_token_id is not None:
-            processors.append(TFForcedBOSTokenLogitsProcessor(generation_config.forced_bos_token_id))
-        if generation_config.forced_eos_token_id is not None:
-            processors.append(
-                TFForcedEOSTokenLogitsProcessor(generation_config.max_length, generation_config.forced_eos_token_id)
-            )
-        if generation_config.suppress_tokens is not None:
-            processors.append(TFSuppressTokensLogitsProcessor(generation_config.suppress_tokens))
-        if generation_config.begin_suppress_tokens is not None:
-            begin_index = input_ids_seq_length
-            begin_index = (
-                begin_index
-                if (input_ids_seq_length > 1 or generation_config.forced_bos_token_id is None)
-                else begin_index + 1
-            )
-            if generation_config.forced_decoder_ids is not None:
-                begin_index += generation_config.forced_decoder_ids[-1][
-                    0
-                ]  # generation starts after the last token that is forced
-            processors.append(
-                TFSuppressTokensAtBeginLogitsProcessor(generation_config.begin_suppress_tokens, begin_index)
-            )
-        if generation_config.forced_decoder_ids is not None:
-            processors.append(TFForceTokensLogitsProcessor(generation_config.forced_decoder_ids))
-
-        processors = self._merge_criteria_processor_list(processors, logits_processor)
-        return processors
-
-    def _merge_criteria_processor_list(
-        self,
-        default_list: TFLogitsProcessorList,
-        custom_list: TFLogitsProcessorList,
-    ) -> TFLogitsProcessorList:
-        if len(custom_list) == 0:
-            return default_list
-        for default in default_list:
-            for custom in custom_list:
-                if type(custom) is type(default):
-                    object_type = "logits processor"
-                    raise ValueError(
-                        f"A custom {object_type} of type {type(custom)} with values {custom} has been passed to"
-                        f" `generate`, but it has already been created with the values {default}. {default} has been"
-                        " created by passing the corresponding arguments to generate or by the model's config default"
-                        f" values. If you just want to change the default values of {object_type} consider passing"
-                        f" them as arguments to `generate` instead of using a custom {object_type}."
-                    )
-        default_list.extend(custom_list)
-        return default_list
-
-    def greedy_search(
-        self,
-        input_ids: tf.Tensor,
-        max_length: Optional[int] = None,
-        pad_token_id: Optional[int] = None,
-        eos_token_id: Optional[int] = None,
-        logits_processor: Optional[TFLogitsProcessorList] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        output_scores: Optional[bool] = None,
-        return_dict_in_generate: Optional[bool] = None,
-        **model_kwargs,
-    ) -> Union[TFGreedySearchOutput, tf.Tensor]:
-        r"""
-        Generates sequences for models with a language modeling head using greedy decoding.
-
-        Parameters:
-            input_ids (`tf.Tensor` of shape `(batch_size, sequence_length)`):
-                The sequence used as a prompt for the generation.
-            logits_processor (`TFLogitsProcessorList`, *optional*):
-                An instance of [`TFLogitsProcessorList`]. List of instances of class derived from [`TFLogitsProcessor`]
-                used to modify the prediction scores of the language modeling head applied at each generation step.
-            max_length (`int`, *optional*, defaults to 20):
-                The maximum length of the sequence to be generated.
-            pad_token_id (`int`, *optional*):
-                The id of the *padding* token.
-            eos_token_id (`Union[int, List[int]]`, *optional*):
-                The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
-            output_attentions (`bool`, *optional*, defaults to `False`):
-                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
-                returned tensors for more details.
-            output_hidden_states (`bool`, *optional*, defaults to `False`):
-                Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
-                for more details.
-            output_scores (`bool`, *optional*, defaults to `False`):
-                Whether or not to return the prediction scores. See `scores` under returned tensors for more details.
-            return_dict_in_generate (`bool`, *optional*, defaults to `False`):
-                Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
-            model_kwargs:
-                Additional model specific keyword arguments will be forwarded to the `call` function of the model. If
-                model is an encoder-decoder model the kwargs should include `encoder_outputs`.
-
-        Return:
-            [`~generation.TFGreedySearchDecoderOnlyOutput`], [`~generation.TFGreedySearchEncoderDecoderOutput`] or
-            `tf.Tensor`: A `tf.Tensor` containing the generated tokens (default behaviour) or a
-            [`~generation.TFGreedySearchDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and
-            `return_dict_in_generate=True` or a [`~generation.TFGreedySearchEncoderDecoderOutput`] if
-            `model.config.is_encoder_decoder=True`.
-
-        Examples:
-
-        ```python
-        >>> from transformers import (
-        ...     AutoTokenizer,
-        ...     TFAutoModelForCausalLM,
-        ...     TFLogitsProcessorList,
-        ...     TFMinLengthLogitsProcessor,
-        ... )
-
-        >>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
-        >>> model = TFAutoModelForCausalLM.from_pretrained("gpt2")
-
-        >>> # set pad_token_id to eos_token_id because GPT2 does not have a PAD token
-        >>> model.generation_config.pad_token_id = model.generation_config.eos_token_id
-
-        >>> input_prompt = "Today is a beautiful day, and"
-        >>> input_ids = tokenizer(input_prompt, return_tensors="tf").input_ids
-
-        >>> # instantiate logits processors
-        >>> logits_processor = TFLogitsProcessorList(
-        ...     [
-        ...         TFMinLengthLogitsProcessor(15, eos_token_id=model.generation_config.eos_token_id),
-        ...     ]
-        ... )
-
-        >>> outputs = model.greedy_search(input_ids, logits_processor=logits_processor)
-        >>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
-        ["Today is a beautiful day, and I'm so happy to be here. I'm so happy to"]
-        ```"""
-
-        # 1. init greedy_search values
-        logits_processor = logits_processor if logits_processor is not None else TFLogitsProcessorList()
-
-        max_length = max_length if max_length is not None else self.generation_config.max_length
-        pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
-        eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
-        if isinstance(eos_token_id, int):
-            eos_token_id = [eos_token_id]
-        output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
-        output_attentions = (
-            output_attentions if output_attentions is not None else self.generation_config.output_attentions
-        )
-        output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
-        )
-        return_dict_in_generate = (
-            return_dict_in_generate
-            if return_dict_in_generate is not None
-            else self.generation_config.return_dict_in_generate
-        )
-        use_cache = model_kwargs.pop("use_cache", self.generation_config.use_cache)
-        use_xla = not tf.executing_eagerly()
-        # TODO (Joao): fix cache format or find programatic way to detect cache index
-        # GPT2 and other models has a slightly different cache structure, with a different batch axis
-        model_name = str(self.decoder) if "EncoderDecoder" in str(self) else str(self)
-        cache_batch_axis = 1 if any(model_prefix in model_name for model_prefix in ("TFGPT2", "TFCTRL")) else 0
-        # some models, like XLNet, need more than the last token in the presence of past_key_values
-        needs_full_input = "use_mems" in set(inspect.signature(self.prepare_inputs_for_generation).parameters.keys())
-
-        # 2. init `attentions`, `hidden_states`, and `scores` tuples
-        scores = [] if (return_dict_in_generate and output_scores) else None
-        decoder_attentions = [] if (return_dict_in_generate and output_attentions) else None
-        cross_attentions = [] if (return_dict_in_generate and output_attentions) else None
-        decoder_hidden_states = [] if (return_dict_in_generate and output_hidden_states) else None
-
-        # 3. init tensors to use for "xla-compileable" generate function
-        batch_size, cur_len = shape_list(input_ids)
-
-        # initialize `generated` (`input_ids` padded with `pad_token_id`), `finished_sequences`
-        input_ids_padding = tf.ones((batch_size, max_length - cur_len), dtype=tf.int32) * (pad_token_id or 0)
-        generated = tf.concat([input_ids, input_ids_padding], axis=-1)
-        finished_sequences = tf.zeros((batch_size,), dtype=tf.bool)
-
-        # 4. define "xla-compile-able" stop-condition and auto-regressive function
-        # define condition fn
-        def greedy_search_cond_fn(generated, finished_sequences, cur_len, model_kwargs):
-            """state termination condition fn."""
-            return ~tf.reduce_all(finished_sequences)
-
-        # define condition fn
-        def greedy_search_body_fn(generated, finished_sequences, cur_len, model_kwargs):
-            """state update fn."""
-            if model_kwargs.get("past_key_values") is None or needs_full_input:
-                input_ids = generated[:, :cur_len]
-            else:
-                input_ids = tf.expand_dims(generated[:, cur_len - 1], -1)
-            model_inputs = self.prepare_inputs_for_generation(input_ids, use_cache=use_cache, **model_kwargs)
-            # forward pass to get next token logits
-            model_outputs = self(
-                **model_inputs,
-                return_dict=True,
-                output_attentions=output_attentions,
-                output_hidden_states=output_hidden_states,
-            )
-            next_token_logits = model_outputs.logits[:, -1]
-
-            # pre-process distribution
-            next_tokens_scores = logits_processor(generated, next_token_logits, cur_len)
-
-            # Store scores, attentions and hidden_states when required
-            if not use_xla and return_dict_in_generate:
-                if output_scores:
-                    scores.append(next_tokens_scores)
-                if output_attentions and self.config.is_encoder_decoder:
-                    decoder_attentions.append(model_outputs.decoder_attentions)
-                elif output_attentions and not self.config.is_encoder_decoder:
-                    decoder_attentions.append(model_outputs.attentions)
-                    if self.config.is_encoder_decoder:
-                        cross_attentions.append(model_outputs.cross_attentions)
-
-                if output_hidden_states and self.config.is_encoder_decoder:
-                    decoder_hidden_states.append(model_outputs.decoder_hidden_states)
-                elif output_hidden_states and self.config.is_encoder_decoder:
-                    decoder_hidden_states.append(model_outputs.hidden_states)
-
-            # argmax
-            next_tokens = tf.argmax(next_tokens_scores, axis=-1, output_type=tf.int32)
-
-            if eos_token_id is not None:
-                if pad_token_id is None:
-                    raise ValueError("If `eos_token_id` is defined, make sure that `pad_token_id` is defined.")
-                unfinished_seq = 1 - tf.cast(finished_sequences, tf.int32)
-                next_tokens = next_tokens * unfinished_seq + pad_token_id * (1 - unfinished_seq)
-                next_token_is_eos = tf.math.reduce_any(
-                    tf.equal(
-                        tf.broadcast_to(next_tokens, (len(eos_token_id), batch_size)), tf.expand_dims(eos_token_id, -1)
-                    ),
-                    axis=0,
-                )
-                finished_sequences = finished_sequences | next_token_is_eos
-
-            # update `generated` and `cur_len`
-            update_indices = tf.stack([tf.range(batch_size), tf.broadcast_to(cur_len, [batch_size])], axis=-1)
-            generated = tf.tensor_scatter_nd_update(tensor=generated, indices=update_indices, updates=next_tokens)
-            cur_len += 1
-
-            # update model_kwargs
-            if use_xla:
-                model_kwargs = self._update_model_kwargs_for_xla_generation(
-                    model_outputs=model_outputs,
-                    model_kwargs=model_kwargs,
-                    cur_len=cur_len,
-                    max_length=max_length,
-                    batch_size=batch_size,
-                    is_encoder_decoder=self.config.is_encoder_decoder,
-                    batch_axis=cache_batch_axis,
-                )
-            else:
-                model_kwargs = self._update_model_kwargs_for_generation(
-                    model_outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
-                )
-                # if we don't cache past_key_values key values we need the whole input
-                if model_kwargs.get("past_key_values", None) is None:
-                    # let's throw out `past_key_values` since we don't want `None` tensors
-                    model_kwargs.pop("past_key_values", None)
-
-            return generated, finished_sequences, cur_len, model_kwargs
-
-        # 5. run generation
-        # 1st generation step has to be run before to initialize `past_key_values`
-        generated, finished_sequences, cur_len, model_kwargs = greedy_search_body_fn(
-            generated, finished_sequences, cur_len, model_kwargs
-        )
-
-        # 2-to-n generation steps can then be run in autoregressive fashion
-        # only in case 1st generation step does NOT yield EOS token though
-        maximum_iterations = max_length - cur_len
-        generated, _, cur_len, _ = tf.while_loop(
-            greedy_search_cond_fn,
-            greedy_search_body_fn,
-            (generated, finished_sequences, cur_len, model_kwargs),
-            maximum_iterations=maximum_iterations,
-        )
-
-        # 6. prepare outputs
-        if not use_xla:
-            # cut for backward compatibility
-            generated = generated[:, :cur_len]
-
-        if return_dict_in_generate:
-            if self.config.is_encoder_decoder:
-                # if model is an encoder-decoder, retrieve encoder attention weights
-                # and hidden states
-                encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
-                encoder_hidden_states = (
-                    model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
-                )
-
-                scores = tuple(scores) if scores is not None else None
-                decoder_attentions = tuple(decoder_attentions) if decoder_attentions is not None else None
-                cross_attentions = tuple(cross_attentions) if cross_attentions is not None else None
-                decoder_hidden_states = tuple(decoder_hidden_states) if decoder_hidden_states is not None else None
-
-                return TFGreedySearchEncoderDecoderOutput(
-                    sequences=generated,
-                    scores=scores,
-                    encoder_attentions=encoder_attentions,
-                    encoder_hidden_states=encoder_hidden_states,
-                    decoder_attentions=decoder_attentions,
-                    cross_attentions=cross_attentions,
-                    decoder_hidden_states=decoder_hidden_states,
-                )
-            else:
-                return TFGreedySearchDecoderOnlyOutput(
-                    sequences=generated,
-                    scores=scores,
-                    attentions=decoder_attentions,
-                    hidden_states=decoder_hidden_states,
-                )
-        else:
-            return generated
-
-    def sample(
-        self,
-        input_ids: tf.Tensor,
-        logits_processor: Optional[TFLogitsProcessorList] = None,
-        logits_warper: Optional[TFLogitsProcessorList] = None,
-        max_length: Optional[int] = None,
-        pad_token_id: Optional[int] = None,
-        eos_token_id: Optional[int] = None,
-        seed: Optional[Tuple[int, int]] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        output_scores: Optional[bool] = None,
-        return_dict_in_generate: Optional[bool] = None,
-        **model_kwargs,
-    ) -> Union[TFSampleOutput, tf.Tensor]:
-        r"""
-        Generates sequences for models with a language modeling head using multinomial sampling.
-
-        Parameters:
-            input_ids (`tf.Tensor` of shape `(batch_size, sequence_length)`):
-                The sequence used as a prompt for the generation.
-            logits_processor (`TFLogitsProcessorList`, *optional*):
-                An instance of [`TFLogitsProcessorList`]. List of instances of class derived from [`TFLogitsProcessor`]
-                used to modify the prediction scores of the language modeling head applied at each generation step.
-            logits_warper (`TFLogitsProcessorList`, *optional*):
-                An instance of [`TFLogitsProcessorList`]. List of instances of class derived from [`TFLogitsWarper`]
-                used to warp the prediction score distribution of the language modeling head applied before multinomial
-                sampling at each generation step.
-            max_length (`int`, *optional*, defaults to 20):
-                The maximum length of the sequence to be generated.
-            pad_token_id (`int`, *optional*):
-                The id of the *padding* token.
-            eos_token_id (`Union[int, List[int]]`, *optional*):
-                The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
-            seed (`List[int]`, *optional*):
-                Random seed to control sampling, containing two integers, used when `do_sample` is `True`. See the
-                `seed` argument from stateless functions in `tf.random`.
-            output_attentions (`bool`, *optional*, defaults to `False`):
-                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
-                returned tensors for more details.
-            output_hidden_states (`bool`, *optional*, defaults to `False`):
-                Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
-                for more details.
-            output_scores (`bool`, *optional*, defaults to `False`):
-                Whether or not to return the prediction scores. See `scores` under returned tensors for more details.
-            return_dict_in_generate (`bool`, *optional*, defaults to `False`):
-                Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
-            model_kwargs:
-                Additional model specific kwargs will be forwarded to the `call` function of the model. If model is an
-                encoder-decoder model the kwargs should include `encoder_outputs`.
-
-        Return:
-            [`~generation.TFSampleDecoderOnlyOutput`], [`~generation.TFSampleEncoderDecoderOutput`] or `tf.Tensor`: A
-            `tf.Tensor` containing the generated tokens (default behaviour) or a
-            [`~generation.TFSampleDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and
-            `return_dict_in_generate=True` or a [`~generation.TFSampleEncoderDecoderOutput`] if
-            `model.config.is_encoder_decoder=True`.
-
-        Examples:
-
-        ```python
-        >>> import tensorflow as tf
-        >>> from transformers import (
-        ...     AutoTokenizer,
-        ...     TFAutoModelForCausalLM,
-        ...     TFLogitsProcessorList,
-        ...     TFMinLengthLogitsProcessor,
-        ...     TFTopKLogitsWarper,
-        ...     TFTemperatureLogitsWarper,
-        ... )
-
-        >>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
-        >>> model = TFAutoModelForCausalLM.from_pretrained("gpt2")
-
-        >>> # set pad_token_id to eos_token_id because GPT2 does not have a EOS token
-        >>> model.generation_config.pad_token_id = model.generation_config.eos_token_id
-
-        >>> input_prompt = "Today is a beautiful day, and"
-        >>> input_ids = tokenizer(input_prompt, return_tensors="tf").input_ids
-
-        >>> # instantiate logits processors
-        >>> logits_processor = TFLogitsProcessorList(
-        ...     [
-        ...         TFMinLengthLogitsProcessor(15, eos_token_id=model.generation_config.eos_token_id),
-        ...     ]
-        ... )
-        >>> # instantiate logits processors
-        >>> logits_warper = TFLogitsProcessorList(
-        ...     [
-        ...         TFTopKLogitsWarper(50),
-        ...         TFTemperatureLogitsWarper(0.7),
-        ...     ]
-        ... )
-
-        >>> tf.random.set_seed(0)
-        >>> outputs = model.sample(input_ids, logits_processor=logits_processor, logits_warper=logits_warper)
-
-        >>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
-        ['Today is a beautiful day, and I love my country. But when I look at Donald Trump,']
-        ```"""
-
-        # 1. init greedy_search values
-        logits_processor = logits_processor if logits_processor is not None else TFLogitsProcessorList()
-        logits_warper = logits_warper if logits_warper is not None else TFLogitsProcessorList()
-
-        max_length = max_length if max_length is not None else self.generation_config.max_length
-        pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
-        eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
-        if isinstance(eos_token_id, int):
-            eos_token_id = [eos_token_id]
-        output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
-        output_attentions = (
-            output_attentions if output_attentions is not None else self.generation_config.output_attentions
-        )
-        output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
-        )
-        return_dict_in_generate = (
-            return_dict_in_generate
-            if return_dict_in_generate is not None
-            else self.generation_config.return_dict_in_generate
-        )
-        use_cache = model_kwargs.pop("use_cache", self.generation_config.use_cache)
-        use_xla = not tf.executing_eagerly()
-        # TODO (Joao): fix cache format or find programatic way to detect cache index
-        # GPT2 and other models has a slightly different cache structure, with a different batch axis
-        model_name = str(self.decoder) if "EncoderDecoder" in str(self) else str(self)
-        cache_batch_axis = 1 if any(model_prefix in model_name for model_prefix in ("TFGPT2", "TFCTRL")) else 0
-        # some models, like XLNet, need more than the last token in the presence of past_key_values
-        needs_full_input = "use_mems" in set(inspect.signature(self.prepare_inputs_for_generation).parameters.keys())
-
-        # 2. init `attentions`, `hidden_states`, and `scores` tuples
-        scores = [] if (return_dict_in_generate and output_scores) else None
-        decoder_attentions = [] if (return_dict_in_generate and output_attentions) else None
-        cross_attentions = [] if (return_dict_in_generate and output_attentions) else None
-        decoder_hidden_states = [] if (return_dict_in_generate and output_hidden_states) else None
-
-        # 3. init tensors to use for "xla-compileable" generate function
-        batch_size, cur_len = shape_list(input_ids)
-
-        # initialize `generated` (pre-populated with `pad_token_id`), `finished_sequences`
-        input_ids_padding = tf.ones((batch_size, max_length - cur_len), dtype=tf.int32) * (pad_token_id or 0)
-        generated = tf.concat([input_ids, input_ids_padding], axis=-1)
-        finished_sequences = tf.zeros((batch_size,), dtype=tf.bool)
-
-        # 4. define "xla-compile-able" stop-condition and auto-regressive function
-        def sample_cond_fn(generated, finished_sequences, cur_len, model_kwargs):
-            return ~tf.reduce_all(finished_sequences)
-
-        def sample_body_fn(generated, finished_sequences, cur_len, model_kwargs):
-            if model_kwargs.get("past_key_values") is None or needs_full_input:
-                input_ids = generated[:, :cur_len]
-            else:
-                input_ids = tf.expand_dims(generated[:, cur_len - 1], -1)
-            model_inputs = self.prepare_inputs_for_generation(input_ids, use_cache=use_cache, **model_kwargs)
-            # forward pass to get next token logits
-            model_outputs = self(
-                **model_inputs,
-                return_dict=True,
-                output_attentions=output_attentions,
-                output_hidden_states=output_hidden_states,
-            )
-            next_token_logits = model_outputs.logits[:, -1]
-
-            # pre-process distribution
-            next_tokens_scores = logits_processor(generated, next_token_logits, cur_len)
-            next_tokens_scores = logits_warper(generated, next_tokens_scores, cur_len)
-
-            # Store scores, attentions and hidden_states when required
-            if not use_xla and return_dict_in_generate:
-                if output_scores:
-                    scores.append(next_tokens_scores)
-                if output_attentions and self.config.is_encoder_decoder:
-                    decoder_attentions.append(model_outputs.decoder_attentions)
-                elif output_attentions and not self.config.is_encoder_decoder:
-                    decoder_attentions.append(model_outputs.attentions)
-                    if self.config.is_encoder_decoder:
-                        cross_attentions.append(model_outputs.cross_attentions)
-
-                if output_hidden_states and self.config.is_encoder_decoder:
-                    decoder_hidden_states.append(model_outputs.decoder_hidden_states)
-                elif output_hidden_states and self.config.is_encoder_decoder:
-                    decoder_hidden_states.append(model_outputs.hidden_states)
-
-            # sample
-            if seed is not None:
-                sample_seed = seed
-            else:
-                sample_seed = tf.experimental.numpy.random.randint(tf.int32.min, tf.int32.max, (2,), dtype=tf.int32)
-            next_tokens = tf.squeeze(
-                tf.random.stateless_categorical(
-                    logits=next_tokens_scores, num_samples=1, seed=sample_seed, dtype=tf.int32
-                ),
-                axis=1,
-            )
-
-            if eos_token_id is not None:
-                if pad_token_id is None:
-                    raise ValueError("If `eos_token_id` is defined, make sure that `pad_token_id` is defined.")
-                unfinished_seq = 1 - tf.cast(finished_sequences, tf.int32)
-                next_tokens = next_tokens * unfinished_seq + pad_token_id * (1 - unfinished_seq)
-                next_token_is_eos = tf.math.reduce_any(
-                    tf.equal(
-                        tf.broadcast_to(next_tokens, (len(eos_token_id), batch_size)), tf.expand_dims(eos_token_id, -1)
-                    ),
-                    axis=0,
-                )
-                finished_sequences = finished_sequences | next_token_is_eos
-
-            # update `generated` and `cur_len`
-            update_indices = tf.stack([tf.range(batch_size), tf.broadcast_to(cur_len, [batch_size])], axis=-1)
-            generated = tf.tensor_scatter_nd_update(tensor=generated, indices=update_indices, updates=next_tokens)
-            cur_len += 1
-
-            # update model_kwargs
-            if use_xla:
-                model_kwargs = self._update_model_kwargs_for_xla_generation(
-                    model_outputs=model_outputs,
-                    model_kwargs=model_kwargs,
-                    cur_len=cur_len,
-                    max_length=max_length,
-                    batch_size=batch_size,
-                    is_encoder_decoder=self.config.is_encoder_decoder,
-                    batch_axis=cache_batch_axis,
-                )
-            else:
-                model_kwargs = self._update_model_kwargs_for_generation(
-                    model_outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
-                )
-                # if we don't cache past_key_values key values we need the whole input
-                if model_kwargs.get("past_key_values", None) is None:
-                    # let's throw out `past_key_values` since we don't want `None` tensors
-                    model_kwargs.pop("past_key_values", None)
-
-            return generated, finished_sequences, cur_len, model_kwargs
-
-        # 5. run generation
-        # 1st generation step has to be run before to initialize `past_key_values`
-        generated, finished_sequences, cur_len, model_kwargs = sample_body_fn(
-            generated, finished_sequences, cur_len, model_kwargs
-        )
-
-        # 2-to-n generation steps can then be run in autoregressive fashion
-        # only in case 1st generation step does NOT yield EOS token though
-        maximum_iterations = max_length - cur_len
-        generated, _, cur_len, _ = tf.while_loop(
-            sample_cond_fn,
-            sample_body_fn,
-            (generated, finished_sequences, cur_len, model_kwargs),
-            maximum_iterations=maximum_iterations,
-        )
-
-        # 6. prepare outputs
-        if not use_xla:
-            # cut for backward compatibility
-            generated = generated[:, :cur_len]
-
-        if return_dict_in_generate:
-            if self.config.is_encoder_decoder:
-                # if model is an encoder-decoder, retrieve encoder attention weights
-                # and hidden states
-                encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
-                encoder_hidden_states = (
-                    model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
-                )
-
-                scores = tuple(scores) if scores is not None else None
-                decoder_attentions = tuple(decoder_attentions) if decoder_attentions is not None else None
-                cross_attentions = tuple(cross_attentions) if cross_attentions is not None else None
-                decoder_hidden_states = tuple(decoder_hidden_states) if decoder_hidden_states is not None else None
-
-                return TFSampleEncoderDecoderOutput(
-                    sequences=generated,
-                    scores=scores,
-                    encoder_attentions=encoder_attentions,
-                    encoder_hidden_states=encoder_hidden_states,
-                    decoder_attentions=decoder_attentions,
-                    cross_attentions=cross_attentions,
-                    decoder_hidden_states=decoder_hidden_states,
-                )
-            else:
-                return TFSampleDecoderOnlyOutput(
-                    sequences=generated,
-                    scores=scores,
-                    attentions=decoder_attentions,
-                    hidden_states=decoder_hidden_states,
-                )
-        else:
-            return generated
-
-    @staticmethod
-    def _gather_beams(nested, beam_indices, batch_axis=0):
-        """Gathers the beam slices indexed by beam_indices into new beam array."""
-
-        def gather_fn(tensor):
-            if batch_axis > 0:
-                # pushes all dimentions before the batch to the end, so we get (batch, beam_id, ...)
-                perm = tf.concat((tf.range(tf.rank(tensor))[batch_axis:], tf.range(batch_axis)), axis=0)
-                tensor = tf.transpose(tensor, perm=perm)
-
-            gathered_tensor = tf.gather(params=tensor, indices=beam_indices, axis=1, batch_dims=1)
-            if batch_axis > 0:
-                # transposes back to the original dimensions
-                perm = tf.concat((tf.range(tf.rank(tensor))[batch_axis:], tf.range(batch_axis)), axis=0)
-                perm = tf.math.invert_permutation(perm)
-                gathered_tensor = tf.transpose(gathered_tensor, perm=perm)
-
-            return gathered_tensor
-
-        return tf.nest.map_structure(gather_fn, nested)
-
-    def beam_search(
-        self,
-        input_ids: tf.Tensor,
-        do_sample: bool = False,
-        max_length: Optional[int] = None,
-        pad_token_id: Optional[int] = None,
-        eos_token_id: Optional[int] = None,
-        length_penalty: Optional[float] = None,
-        early_stopping: Optional[Union[bool, str]] = None,
-        logits_processor: Optional[TFLogitsProcessorList] = None,
-        logits_warper: Optional[TFLogitsProcessorList] = None,
-        num_return_sequences: Optional[int] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        output_scores: Optional[bool] = None,
-        return_dict_in_generate: Optional[bool] = None,
-        **model_kwargs,
-    ) -> Union[TFBeamSearchOutput, TFBeamSampleOutput, tf.Tensor]:
-        r"""
-        Generates sequences for models with a language modeling head using beam search. If `do_sample` is `False`, uses
-        a greedy approach, otherwise does multinomial sampling without replacement.
-
-        Parameters:
-            input_ids (`tf.Tensor` of shape `(batch_size, sequence_length)`):
-                The sequence used as a prompt for the generation.
-            do_sample (`bool`, *optional*, defaults to `False`):
-                Whether or not to use sampling ; use greedy decoding otherwise.
-            max_length (`int`, *optional*, defaults to 20):
-                The maximum length of the sequence to be generated.
-            pad_token_id (`int`, *optional*):
-                The id of the *padding* token.
-            eos_token_id (`Union[int, List[int]]`, *optional*):
-                The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
-            length_penalty (`float`, *optional*, defaults to 1.0):
-                Exponential penalty to the length that is used with beam-based generation. It is applied as an exponent
-                to the sequence length, which in turn is used to divide the score of the sequence. Since the score is
-                the log likelihood of the sequence (i.e. negative), `length_penalty` > 0.0 promotes longer sequences,
-                while `length_penalty` < 0.0 encourages shorter sequences.
-            early_stopping (`bool` or `str`, *optional*, defaults to `False`):
-                Controls the stopping condition for beam-based methods, like beam-search. It accepts the following
-                values: `True`, where the generation stops as soon as there are `num_beams` complete candidates;
-                `False`, where an heuristic is applied and the generation stops when is it very unlikely to find better
-                candidates; `"never"`, where the beam search procedure only stops when there cannot be better
-                candidates (canonical beam search algorithm).
-            logits_processor (`[TFLogitsProcessorList]`, *optional*):
-                An instance of [`TFLogitsProcessorList`]. List of instances of class derived from [`TFLogitsProcessor`]
-                used to modify the prediction scores of the language modeling head applied at each generation step.
-            logits_warper (`TFLogitsProcessorList`, *optional*):
-                An instance of [`TFLogitsProcessorList`]. List of instances of class derived from [`TFLogitsWarper`]
-                used to warp the prediction score distribution of the language modeling head applied before multinomial
-                sampling at each generation step.
-            num_return_sequences(`int`, *optional*, defaults to 1):
-                The number of independently computed returned sequences for each element in the batch.
-            output_attentions (`bool`, *optional*, defaults to `False`):
-                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
-                returned tensors for more details.
-            output_hidden_states (`bool`, *optional*, defaults to `False`):
-                Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
-                for more details.
-            return_dict_in_generate (`bool`, *optional*, defaults to `False`):
-                Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.
-            model_kwargs:
-                Additional model specific kwargs will be forwarded to the `call` function of the model. If model is an
-                encoder-decoder model the kwargs should include `encoder_outputs`.
-
-        Return:
-            [`~generation.TFBeamSearchDecoderOnlyOutput`], [`~generation.TFBeamSearchEncoderDecoderOutput`] or
-            `tf.Tensor`: A `tf.Tensor` containing the generated tokens (default behaviour) or a
-            [`~generation.TFBeamSearchDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and
-            `return_dict_in_generate=True` or a [`~generation.TFBeamSearchEncoderDecoderOutput`] if
-            `model.config.is_encoder_decoder=True`.
-
-        Examples:
-
-        ```python
-        >>> from transformers import (
-        ...     AutoTokenizer,
-        ...     TFAutoModelForSeq2SeqLM,
-        ...     TFLogitsProcessorList,
-        ...     TFMinLengthLogitsProcessor,
-        ... )
-        >>> import tensorflow as tf
-
-        >>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
-        >>> model = TFAutoModelForSeq2SeqLM.from_pretrained("t5-base")
-
-        >>> encoder_input_str = "translate English to German: How old are you?"
-        >>> encoder_input_ids = tokenizer(encoder_input_str, return_tensors="tf").input_ids
-
-        >>> # lets run beam search using 3 beams
-        >>> num_beams = 3
-        >>> # define decoder start token ids
-        >>> input_ids = tf.ones((1, num_beams, 1), dtype=tf.int32)
-        >>> input_ids = input_ids * model.generation_config.decoder_start_token_id
-
-        >>> # add encoder_outputs to model keyword arguments
-        >>> encoder_outputs = model.get_encoder()(encoder_input_ids, return_dict=True)
-        >>> encoder_outputs.last_hidden_state = tf.repeat(
-        ...     tf.expand_dims(encoder_outputs.last_hidden_state, axis=0), num_beams, axis=1
-        ... )
-        >>> model_kwargs = {"encoder_outputs": encoder_outputs}
-
-        >>> # instantiate logits processors
-        >>> logits_processor = TFLogitsProcessorList(
-        ...     [TFMinLengthLogitsProcessor(5, eos_token_id=model.generation_config.eos_token_id)]
-        ... )
-
-        >>> outputs = model.beam_search(input_ids, logits_processor=logits_processor, **model_kwargs)
-        >>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
-        ['Wie alt bist du?']
-        ```"""
-
-        def flatten_beam_dim(tensor, batch_axis=0):
-            """Flattens the first two dimensions of a non-scalar array."""
-            shape = shape_list(tensor)
-            return tf.reshape(
-                tensor,
-                shape[:batch_axis] + [shape[batch_axis] * shape[batch_axis + 1]] + shape[batch_axis + 2 :],
-            )
-
-        def unflatten_beam_dim(tensor, num_beams, batch_axis=0):
-            """Unflattens the first, flat batch*beam dimension of a non-scalar array."""
-            shape = shape_list(tensor)
-            return tf.reshape(tensor, shape[:batch_axis] + [-1, num_beams] + shape[batch_axis + 1 :])
-
-        # 1. init beam_search values
-        logits_processor = logits_processor if logits_processor is not None else TFLogitsProcessorList()
-        logits_warper = logits_warper if logits_warper is not None else TFLogitsProcessorList()
-
-        max_length = max_length if max_length is not None else self.generation_config.max_length
-        pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
-        eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
-        if isinstance(eos_token_id, int):
-            eos_token_id = [eos_token_id]
-        num_return_sequences = (
-            num_return_sequences if num_return_sequences is not None else self.generation_config.num_return_sequences
-        )
-
-        output_attentions = (
-            output_attentions if output_attentions is not None else self.generation_config.output_attentions
-        )
-        output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
-        )
-        output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
-        return_dict_in_generate = (
-            return_dict_in_generate
-            if return_dict_in_generate is not None
-            else self.generation_config.return_dict_in_generate
-        )
-
-        length_penalty = length_penalty if length_penalty is not None else self.generation_config.length_penalty
-        early_stopping = early_stopping if early_stopping is not None else self.generation_config.early_stopping
-
-        use_cache = model_kwargs.pop("use_cache", self.generation_config.use_cache)
-        use_xla = not tf.executing_eagerly()
-        # TODO (Joao): fix cache format or find programatic way to detect cache index
-        # GPT2 and other models has a slightly different cache structure, with a different batch axis
-        model_name = str(self.decoder) if "EncoderDecoder" in str(self) else str(self)
-        cache_batch_axis = 1 if any(model_prefix in model_name for model_prefix in ("TFGPT2", "TFCTRL")) else 0
-        # some models, like XLNet, need more than the last token in the presence of past_key_values
-        needs_full_input = "use_mems" in set(inspect.signature(self.prepare_inputs_for_generation).parameters.keys())
-
-        # 2. init `attentions`, `hidden_states`, and `scores` tuples
-        all_scores = [] if (return_dict_in_generate and output_scores) else None
-        decoder_attentions = [] if (return_dict_in_generate and output_attentions) else None
-        cross_attentions = [] if (return_dict_in_generate and output_attentions) else None
-        decoder_hidden_states = [] if (return_dict_in_generate and output_hidden_states) else None
-
-        # 3. init tensors to use for "xla-compileable" generate function
-        batch_size, num_beams, cur_len = shape_list(input_ids)
-
-        # per batch, beam-item holding current token in loop, pre-populated with `pad_token_id`
-        input_ids_padding = tf.ones((batch_size, num_beams, max_length - cur_len), dtype=tf.int32) * (
-            pad_token_id or 0
-        )
-        running_sequences = tf.concat([input_ids, input_ids_padding], axis=-1)
-        sequences = tf.ones((batch_size, num_beams, max_length), dtype=tf.int32) * (pad_token_id or 0)
-
-        # per batch,beam-item state bit indicating if sentence has finished.
-        is_sent_finished = tf.zeros((batch_size, num_beams), dtype=tf.bool)
-
-        # per batch, beam-item score, logprobs
-        running_scores = tf.tile(
-            tf.expand_dims(tf.convert_to_tensor([0.0] + [-1.0e9] * (num_beams - 1)), axis=0), [batch_size, 1]
-        )
-        scores = tf.ones((batch_size, num_beams)) * -1.0e9
-
-        # per batch beam indices
-        running_beam_indices = tf.ones((batch_size, num_beams, max_length), dtype=tf.int32) * -1
-        beam_indices = tf.ones((batch_size, num_beams, max_length), dtype=tf.int32) * -1
-
-        # flatten beam dim
-        if "encoder_outputs" in model_kwargs:
-            model_kwargs["encoder_outputs"]["last_hidden_state"] = flatten_beam_dim(
-                model_kwargs["encoder_outputs"]["last_hidden_state"]
-            )
-        if "attention_mask" in model_kwargs:
-            model_kwargs["attention_mask"] = flatten_beam_dim(model_kwargs["attention_mask"])
-
-        # 4. define "xla-compile-able" stop-condition and auto-regressive function
-        # define stop-condition and auto-regressive function
-        def beam_search_cond_fn(
-            cur_len,
-            running_sequences,
-            running_scores,
-            running_beam_indices,
-            sequences,
-            scores,
-            beam_indices,
-            is_sent_finished,
-            model_kwargs,
-        ):
-            """
-            Beam Search termination condition function -- halts the generation loop if any of these conditions becomes
-            False
-            """
-            # 1. is less than max length?
-            not_max_length_yet = cur_len < max_length
-
-            # 2. can the new beams still improve?
-            # early_stopping == False -> apply heuristic = always get the best score from `cur_len`. See the discussion
-            # below for more details.
-            # https://github.com/huggingface/transformers/pull/20901#issuecomment-1369845565
-            # early_stopping == "never" -> compute the best score from max_length or cur_len, depending on the sign of
-            #   length_penalty. Positive length_penalty favors longer sequences, thus we use max_length there.
-            if early_stopping == "never" and length_penalty > 0.0:
-                best_running_score = running_scores[:, :1] / (max_length**length_penalty)
-            else:
-                best_running_score = running_scores[:, :1] / (tf.cast(cur_len, dtype=tf.float32) ** length_penalty)
-            worst_finished_score = tf.where(
-                is_sent_finished, tf.math.reduce_min(scores, axis=1, keepdims=True), -1.0e9
-            )
-            improvement_still_possible = tf.math.reduce_any(best_running_score > worst_finished_score)
-
-            # 3. is there still a beam that has not finished?
-            still_open_beam = ~(tf.math.reduce_all(is_sent_finished) & (early_stopping is True))
-
-            return not_max_length_yet & still_open_beam & improvement_still_possible
-
-        def beam_search_body_fn(
-            cur_len,
-            running_sequences,
-            running_scores,
-            running_beam_indices,
-            sequences,
-            scores,
-            beam_indices,
-            is_sent_finished,
-            model_kwargs,
-        ):
-            """
-            Beam Search iterative update function -- each iteration adds a new token and updates the best sequences
-            seen so far
-            """
-            # 1. Forward current tokens
-            if model_kwargs.get("past_key_values") is None or needs_full_input:
-                input_ids = running_sequences[:, :, :cur_len]
-            else:
-                input_ids = tf.expand_dims(running_sequences[:, :, cur_len - 1], -1)
-            model_inputs = self.prepare_inputs_for_generation(
-                flatten_beam_dim(input_ids), use_cache=use_cache, **model_kwargs
-            )
-            model_outputs = self(
-                **model_inputs,
-                return_dict=True,
-                output_attentions=output_attentions,
-                output_hidden_states=output_hidden_states,
-            )
-            logits = unflatten_beam_dim(model_outputs.logits[:, -1], num_beams)
-
-            # 2. Compute log probs
-            # get log probabilities from logits, process logits with processors (*e.g.* min_length, ...), and
-            # add new logprobs to existing running logprobs scores.
-            log_probs = tf.nn.log_softmax(logits)
-            log_probs = logits_processor(flatten_beam_dim(running_sequences), flatten_beam_dim(log_probs), cur_len)
-            log_probs = unflatten_beam_dim(log_probs, num_beams)
-            log_probs_processed = log_probs
-            log_probs = log_probs + tf.expand_dims(running_scores, axis=2)
-            if do_sample:
-                # Note: logits warpers are intentionally applied after adding running beam scores. On some logits
-                # warpers (like top_p) this is indiferent, but on others (like temperature) it is not. For reference,
-                # see https://github.com/huggingface/transformers/pull/5420#discussion_r449779867
-                log_probs = logits_warper(flatten_beam_dim(running_sequences), flatten_beam_dim(log_probs), cur_len)
-                log_probs = unflatten_beam_dim(log_probs, num_beams)
-            vocab_size = log_probs.shape[2]
-            log_probs = tf.reshape(log_probs, (batch_size, num_beams * vocab_size))
-
-            # Store scores, attentions and hidden_states when required
-            if not use_xla and return_dict_in_generate:
-                if output_scores:
-                    all_scores.append(
-                        logits_warper(
-                            flatten_beam_dim(running_sequences), flatten_beam_dim(log_probs_processed), cur_len
-                        )
-                    )
-                if output_attentions and self.config.is_encoder_decoder:
-                    decoder_attentions.append(model_outputs.decoder_attentions)
-                elif output_attentions and not self.config.is_encoder_decoder:
-                    decoder_attentions.append(model_outputs.attentions)
-                    if self.config.is_encoder_decoder:
-                        cross_attentions.append(model_outputs.cross_attentions)
-
-                if output_hidden_states and self.config.is_encoder_decoder:
-                    decoder_hidden_states.append(model_outputs.decoder_hidden_states)
-                elif output_hidden_states and self.config.is_encoder_decoder:
-                    decoder_hidden_states.append(model_outputs.hidden_states)
-
-            # 3. Retrieve top-K
-            # Each item in batch has num_beams * vocab_size candidate sequences. For each item, get the top 2*k
-            # candidates with the highest log-probabilities. We gather the top 2*K beams here so that even if the
-            # best K sequences reach EOS simultaneously, we have another K sequences remaining to continue the live
-            # beam search.
-            # Gather the top 2*K scores from _all_ beams.
-            # Gather 2*k top beams.
-            # Recover the beam index by floor division.
-            # Recover token id by modulo division and expand Id array for broadcasting.
-            # Update sequences for the 2*K top-k new sequences.
-            beams_to_keep = 2 * num_beams
-            if do_sample:
-                topk_indices = sample_without_replacement(log_probs, beams_to_keep)
-                topk_log_probs = tf.gather(log_probs, topk_indices, axis=1, batch_dims=1)
-            else:
-                topk_log_probs, topk_indices = tf.math.top_k(log_probs, k=beams_to_keep)
-            topk_current_beam_indices = topk_indices // vocab_size
-            topk_running_beam_indices = self._gather_beams(running_beam_indices, topk_current_beam_indices)
-            topk_running_sequences = self._gather_beams(running_sequences, topk_current_beam_indices)
-            topk_ids = topk_indices % vocab_size
-
-            # writes the new token
-            indices_batch = tf.repeat(tf.range(batch_size), [beams_to_keep])
-            indices_beam = tf.tile(tf.range(beams_to_keep), [batch_size])
-            update_indices = tf.stack(
-                [indices_batch, indices_beam, tf.broadcast_to(cur_len, [batch_size * beams_to_keep])], axis=-1
-            )
-            topk_sequences = tf.tensor_scatter_nd_update(
-                tensor=topk_running_sequences,
-                indices=update_indices,
-                updates=tf.reshape(topk_ids, [batch_size * beams_to_keep]),
-            )
-
-            # we want to store the beam indices with batch information -> real beam index = beam index % num beams
-            batch_modified_indices = topk_current_beam_indices + tf.broadcast_to(
-                tf.expand_dims(tf.range(batch_size) * num_beams, axis=1), topk_current_beam_indices.shape
-            )
-            topk_beam_indices = tf.tensor_scatter_nd_update(
-                tensor=topk_running_beam_indices,
-                indices=update_indices,
-                updates=tf.reshape(batch_modified_indices, [batch_size * beams_to_keep]),
-            )
-
-            # 4. Check which sequences have ended
-            # Update current sequences: Did the top `num_beams` sequences reach an end marker?
-            # To prevent these just finished sequences from being added to the current sequences
-            # set of active beam search sequences, set their log probs to a very large negative value.
-            if eos_token_id is None:
-                eos_in_next_token = tf.zeros(topk_sequences[:, :, cur_len].shape, dtype=tf.bool)
-            else:
-                eos_in_next_token = tf.math.reduce_any(
-                    tf.equal(
-                        tf.broadcast_to(
-                            topk_sequences[:, :, cur_len], [len(eos_token_id)] + topk_sequences[:, :, cur_len].shape
-                        ),
-                        tf.expand_dims(tf.expand_dims(eos_token_id, -1), -1),
-                    ),
-                    axis=0,
-                )
-            did_topk_just_finished = eos_in_next_token & tf.broadcast_to(
-                tf.concat((tf.ones((num_beams), dtype=tf.bool), tf.zeros((num_beams), dtype=tf.bool)), axis=0),
-                shape_list(eos_in_next_token),
-            )
-
-            # non-top `num_beams` eos tokens can't be used to finish a beam, but the others can't be used in the next
-            # running sentences either
-            running_topk_log_probs = topk_log_probs + tf.cast(eos_in_next_token, tf.float32) * -1.0e9
-
-            # 5. Get running sequences scores for next
-            # Determine the top k beam indices (from top 2*k beams) from log probs and gather top k beams
-            # (from top 2*k beams).
-            next_topk_indices = tf.math.top_k(running_topk_log_probs, k=num_beams)[1]
-            next_running_sequences, next_running_scores, next_running_beam_indices = self._gather_beams(
-                [topk_sequences, running_topk_log_probs, topk_beam_indices], next_topk_indices
-            )
-
-            # 6. Process topk logits
-            # Further process log probs:
-            # - add length penalty
-            # - make sure no scores can be added anymore if beam is full
-            # - make sure still running sequences cannot be chosen as finalized beam
-            topk_log_probs = topk_log_probs / (tf.cast(cur_len, dtype=tf.float32) ** length_penalty)
-            beams_in_batch_are_full = tf.broadcast_to(
-                tf.math.reduce_all(is_sent_finished, axis=-1, keepdims=True), shape_list(did_topk_just_finished)
-            ) & (early_stopping is True)
-            add_penalty = ~did_topk_just_finished | beams_in_batch_are_full
-            topk_log_probs += tf.cast(add_penalty, tf.float32) * -1.0e9
-
-            # 7. Get scores, sequences, is sentence finished for next.
-            # Combine sequences, scores, and flags along the beam dimension and compare new finished sequence scores
-            # to existing finished scores and select the best from the new set of beams
-            merged_sequences = tf.concat([sequences, topk_sequences], axis=1)
-            merged_scores = tf.concat([scores, topk_log_probs], axis=1)
-            merged_beams = tf.concat([beam_indices, topk_beam_indices], axis=1)
-            merged_is_sent_finished = tf.concat([is_sent_finished, did_topk_just_finished], axis=1)
-            topk_merged_indices = tf.math.top_k(merged_scores, k=num_beams)[1]
-            next_sequences, next_scores, next_beam_indices, next_is_sent_finished = self._gather_beams(
-                [merged_sequences, merged_scores, merged_beams, merged_is_sent_finished], topk_merged_indices
-            )
-
-            # 8. Prepare data for the next iteration
-            # Determine the top k beam indices from the original set of all beams. With these, gather the top k
-            # beam-associated caches.
-            cur_len = cur_len + 1
-            if "past_key_values" in model_outputs:
-                cache = tf.nest.map_structure(
-                    lambda tensor: unflatten_beam_dim(tensor, num_beams, batch_axis=cache_batch_axis),
-                    model_outputs.past_key_values,
-                )
-                next_running_indices = self._gather_beams(topk_current_beam_indices, next_topk_indices)
-                next_cache = self._gather_beams(cache, next_running_indices, batch_axis=cache_batch_axis)
-                model_outputs["past_key_values"] = tf.nest.map_structure(
-                    lambda tensor: flatten_beam_dim(tensor, batch_axis=cache_batch_axis), next_cache
-                )
-
-            if use_xla:
-                next_model_kwargs = self._update_model_kwargs_for_xla_generation(
-                    model_outputs=model_outputs,
-                    model_kwargs=model_kwargs,
-                    cur_len=cur_len,
-                    max_length=max_length,
-                    batch_size=(batch_size * num_beams),
-                    is_encoder_decoder=self.config.is_encoder_decoder,
-                    batch_axis=cache_batch_axis,
-                )
-            else:
-                next_model_kwargs = self._update_model_kwargs_for_generation(
-                    model_outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
-                )
-
-                # if we don't cache past_key_values key values we need the whole input
-                if model_kwargs.get("past_key_values", None) is None:
-                    # let's throw out `past_key_values` since we don't want `None` tensors
-                    model_kwargs.pop("past_key_values", None)
-
-            return (
-                cur_len,
-                next_running_sequences,
-                next_running_scores,
-                next_running_beam_indices,
-                next_sequences,
-                next_scores,
-                next_beam_indices,
-                next_is_sent_finished,
-                next_model_kwargs,
-            )
-
-        # 5. run generation
-        # 1st generation step has to be run before to initialize `past_key_values` (if active)
-        (
-            cur_len,
-            running_sequences,
-            running_scores,
-            running_beam_indices,
-            sequences,
-            scores,
-            beam_indices,
-            is_sent_finished,
-            model_kwargs,
-        ) = beam_search_body_fn(
-            cur_len,
-            running_sequences,
-            running_scores,
-            running_beam_indices,
-            sequences,
-            scores,
-            beam_indices,
-            is_sent_finished,
-            model_kwargs,
-        )
-
-        # 2-to-n generation steps can then be run in autoregressive fashion (only in case 1st generation step does
-        # NOT yield EOS token though)
-        maximum_iterations = max_length - cur_len
-        (
-            cur_len,
-            running_sequences,
-            running_scores,
-            running_beam_indices,
-            sequences,
-            scores,
-            beam_indices,
-            is_sent_finished,
-            _,
-        ) = tf.while_loop(
-            beam_search_cond_fn,
-            beam_search_body_fn,
-            (
-                cur_len,
-                running_sequences,
-                running_scores,
-                running_beam_indices,
-                sequences,
-                scores,
-                beam_indices,
-                is_sent_finished,
-                model_kwargs,
-            ),
-            maximum_iterations=maximum_iterations,
-        )
-
-        # 6. prepare outputs
-        # Account for the edge-case where there are no finished sequences for a particular batch item. If so, return
-        # running sequences for that batch item.
-        none_finished = tf.math.reduce_any(is_sent_finished, axis=1)
-        sequences = tf.where(none_finished[:, None, None], sequences, running_sequences)
-        beam_indices = tf.where(none_finished[:, None, None], beam_indices, running_beam_indices)
-
-        # Apply the length penalty so that running scores match the finalized scores if they are used
-        running_scores = running_scores / (tf.cast(cur_len, dtype=tf.float32) ** length_penalty)
-        scores = tf.where(none_finished[:, None], scores, running_scores)
-
-        # Take best beams for each batch (the score is sorted in descending order)
-        sequences = flatten_beam_dim(sequences[:, :num_return_sequences, :])
-        scores = flatten_beam_dim(scores[:, :num_return_sequences])
-        beam_indices = flatten_beam_dim(beam_indices[:, :num_return_sequences, :])
-
-        if not use_xla:
-            # Cut for backward compatibility
-            sequences = sequences[:, :cur_len]
-            beam_indices = beam_indices[:, :cur_len]
-
-        if return_dict_in_generate:
-            if self.config.is_encoder_decoder:
-                # if model is an encoder-decoder, retrieve encoder attention weights and hidden states
-                encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
-                encoder_hidden_states = (
-                    model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
-                )
-
-                output_cls = TFBeamSampleEncoderDecoderOutput if do_sample else TFBeamSearchEncoderDecoderOutput
-                return output_cls(
-                    sequences=sequences,
-                    sequences_scores=scores,
-                    scores=all_scores,
-                    beam_indices=beam_indices,
-                    encoder_attentions=encoder_attentions,
-                    encoder_hidden_states=encoder_hidden_states,
-                    decoder_attentions=decoder_attentions,
-                    cross_attentions=cross_attentions,
-                    decoder_hidden_states=decoder_hidden_states,
-                )
-            else:
-                output_cls = TFBeamSampleDecoderOnlyOutput if do_sample else TFBeamSearchDecoderOnlyOutput
-                return output_cls(
-                    sequences=sequences,
-                    sequences_scores=scores,
-                    scores=all_scores,
-                    beam_indices=beam_indices,
-                    attentions=decoder_attentions,
-                    hidden_states=decoder_hidden_states,
-                )
-        else:
-            return sequences
-
-    def contrastive_search(
-        self,
-        input_ids: tf.Tensor,
-        top_k: Optional[int] = 1,
-        penalty_alpha: Optional[float] = 0,
-        logits_processor: Optional[TFLogitsProcessorList] = None,
-        logits_warper: Optional[TFLogitsProcessorList] = None,
-        max_length: Optional[int] = None,
-        pad_token_id: Optional[int] = None,
-        eos_token_id: Optional[int] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        output_scores: Optional[bool] = None,
-        return_dict_in_generate: Optional[bool] = None,
-        **model_kwargs,
-    ) -> Union[TFContrastiveSearchOutput, tf.Tensor]:
-        r"""
-        Generates sequences of token ids for models with a language modeling head using **contrastive search** and can
-        be used for text-decoder, text-to-text, speech-to-text, and vision-to-text models.
-
-        Parameters:
-            input_ids (`tf.Tensor` of shape `(batch_size, sequence_length)`):
-                The sequence used as a prompt for the generation.
-            top_k (`int`, *optional*, defaults to 1):
-                The size of the candidate set that is used to re-rank for contrastive search
-            penalty_alpha (`float`, *optional*, defaults to 0):
-                The degeneration penalty for contrastive search; activate when it is larger than 0
-            logits_processor (`TFLogitsProcessorList`, *optional*):
-                An instance of [`TFLogitsProcessorList`]. List of instances of class derived from [`TFLogitsProcessor`]
-                used to modify the prediction scores of the language modeling head applied at each generation step.
-            logits_warper (`TFLogitsProcessorList`, *optional*):
-                An instance of [`TFLogitsProcessorList`]. List of instances of class derived from [`TFLogitsWarper`]
-                used to warp the prediction score distribution of the language modeling head applied before multinomial
-                sampling at each generation step.
-            max_length (`int`, *optional*, defaults to 20):
-                The maximum length of the sequence to be generated.
-            pad_token_id (`int`, *optional*):
-                The id of the *padding* token.
-            eos_token_id (`Union[int, List[int]]`, *optional*):
-                The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
-            output_attentions (`bool`, *optional*, defaults to `False`):
-                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
-                returned tensors for more details.
-            output_hidden_states (`bool`, *optional*, defaults to `False`):
-                Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
-                for more details.
-            output_scores (`bool`, *optional*, defaults to `False`):
-                Whether or not to return the prediction scores. See `scores` under returned tensors for more details.
-            return_dict_in_generate (`bool`, *optional*, defaults to `False`):
-                Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
-            model_kwargs:
-                Additional model specific keyword arguments will be forwarded to the `call` function of the model. If
-                model is an encoder-decoder model the kwargs should include `encoder_outputs`.
-        Return:
-            [`~generation.TFContrastiveSearchDecoderOnlyOutput`],
-            [`~generation.TFContrastiveSearchEncoderDecoderOutput`] or `tf.Tensor`: A `tf.Tensor` containing the
-            generated tokens (default behaviour) or a [`~generation.TFContrastiveySearchDecoderOnlyOutput`] if
-            `model.config.is_encoder_decoder=False` and `return_dict_in_generate=True` or a
-            [`~generation.TFContrastiveSearchEncoderDecoderOutput`] if `model.config.is_encoder_decoder=True`.
-        Examples:
-        ```python
-        >>> from transformers import AutoTokenizer, TFAutoModelForCausalLM
-
-        >>> tokenizer = AutoTokenizer.from_pretrained("facebook/opt-125m")
-        >>> model = TFAutoModelForCausalLM.from_pretrained("facebook/opt-125m")
-        >>> # set pad_token_id to eos_token_id because OPT does not have a PAD token
-        >>> model.config.pad_token_id = model.config.eos_token_id
-        >>> input_prompt = "DeepMind Company is"
-        >>> input_ids = tokenizer(input_prompt, return_tensors="tf")
-        >>> outputs = model.contrastive_search(**input_ids, penalty_alpha=0.6, top_k=4, max_length=64)
-        >>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
-        ['DeepMind Company is a company that focuses on the development and commercialization of artificial intelligence (AI). DeepMind’s mission is to help people understand and solve problems that are difficult to solve in the world today.\n\nIn this post, we talk about the benefits of deep learning in business and how it']
-        ```"""
-
-        def gather_best_candidate(nested, selected_idx_stacked, batch_axis=0):
-            """Gathers the slices indexed by selected_idx_stacked from a potentially nested structure of tensors."""
-
-            def gather_fn(tensor):
-                gathered_tensor = tf.gather(params=tensor, indices=selected_idx_stacked, axis=batch_axis)
-                return gathered_tensor
-
-            return tf.nest.map_structure(gather_fn, nested)
-
-        # 1. init greedy_search values
-        logits_processor = logits_processor if logits_processor is not None else TFLogitsProcessorList()
-        logits_warper = logits_warper if logits_warper is not None else TFLogitsProcessorList()
-        max_length = max_length if max_length is not None else self.generation_config.max_length
-        pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
-        eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
-        if isinstance(eos_token_id, int):
-            eos_token_id = [eos_token_id]
-        output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
-        output_attentions = (
-            output_attentions if output_attentions is not None else self.generation_config.output_attentions
-        )
-        output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
-        )
-        return_dict_in_generate = (
-            return_dict_in_generate
-            if return_dict_in_generate is not None
-            else self.generation_config.return_dict_in_generate
-        )
-        use_cache = True  # In contrastive search, we always use cache
-        model_kwargs.pop("use_cache", None)
-
-        use_xla = not tf.executing_eagerly()
-        # TODO (Joao): fix cache format or find programatic way to detect cache index
-        # GPT2 and other models has a slightly different cache structure, with a different batch axis
-        model_name = str(self.decoder) if "EncoderDecoder" in str(self) else str(self)
-        cache_batch_axis = 1 if any(model_prefix in model_name for model_prefix in ("TFGPT2", "TFCTRL")) else 0
-
-        # 2. init `attentions`, `hidden_states`, and `scores` tuples
-        scores = [] if (return_dict_in_generate and output_scores) else None
-        decoder_attentions = [] if (return_dict_in_generate and output_attentions) else None
-        cross_attentions = [] if (return_dict_in_generate and output_attentions) else None
-        decoder_hidden_states = [] if (return_dict_in_generate and output_hidden_states) else None
-
-        # 3. init tensors to use for "xla-compileable" generate function
-        batch_size, cur_len = shape_list(input_ids)
-
-        # initialize `generated` (`input_ids` padded with `pad_token_id`), `finished_sequences`
-        input_ids_padding = tf.ones((batch_size, max_length - cur_len), dtype=tf.int32) * (pad_token_id or 0)
-        generated = tf.concat([input_ids, input_ids_padding], axis=-1)
-        finished_sequences = tf.zeros((batch_size,), dtype=tf.bool)
-
-        # 4. define "xla-compile-able" stop-condition and auto-regressive function
-        # define condition fn
-        def contrastive_search_cond_fn(
-            generated, finished_sequences, cur_len, model_kwargs, next_step_cached_variables
-        ):
-            """state termination condition fn."""
-            return ~tf.reduce_all(finished_sequences)
-
-        # define condition fn
-        def contrastive_search_body_fn(
-            generated, finished_sequences, cur_len, model_kwargs, next_step_cached_variables
-        ):
-            """state update fn."""
-
-            # if the first step in the loop, encode all the prefix and obtain: (1) past_key_values;
-            # (2) last_hidden_states; (3) logit_for_next_step; (4) update model kwargs for the next step
-            if model_kwargs.get("past_key_values") is None:
-                # prepare inputs
-                model_inputs = self.prepare_inputs_for_generation(
-                    generated[:, :cur_len], use_cache=use_cache, **model_kwargs
-                )
-
-                # encode the given prefix and prepare model inputs; encoder-decoder model process the prefix and save
-                # the `encoder_outputs`
-                outputs = self(
-                    **model_inputs, return_dict=True, output_hidden_states=True, output_attentions=output_attentions
-                )
-
-                # last decoder hidden states will be used to compute the degeneration penalty (cosine similarity with
-                # previous tokens)
-                if self.config.is_encoder_decoder:
-                    last_hidden_states = outputs.decoder_hidden_states[-1]
-                else:
-                    last_hidden_states = outputs.hidden_states[-1]
-
-                # XLA: last_hidden_states normally grows at each step, but in XLA it is padded so as to be used across
-                # iterations (with fixed shapes)
-                if use_xla:
-                    last_hidden_states = tf.pad(last_hidden_states, [[0, 0], [0, max_length - cur_len], [0, 0]])
-
-                # next logit for contrastive search to select top-k candidate tokens
-                logit_for_next_step = outputs.logits[:, -1, :]
-
-                if use_xla:
-                    model_kwargs = self._update_model_kwargs_for_xla_generation(
-                        model_outputs=outputs,
-                        model_kwargs=model_kwargs,
-                        cur_len=cur_len,
-                        max_length=max_length,
-                        batch_size=batch_size,
-                        is_encoder_decoder=self.config.is_encoder_decoder,
-                        batch_axis=cache_batch_axis,
-                    )
-                else:
-                    model_kwargs = self._update_model_kwargs_for_generation(
-                        outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
-                    )
-
-                # Expands model inputs top_k times, for batched forward passes (akin to beam search).
-                _, model_kwargs = self._expand_inputs_for_generation(
-                    expand_size=top_k, is_encoder_decoder=self.config.is_encoder_decoder, **model_kwargs
-                )
-
-                past_key_values = model_kwargs.get("past_key_values")
-                if past_key_values is None:
-                    raise ValueError(
-                        f"{self.__class__.__name__} does not support caching and therefore **can't** be used "
-                        "for contrastive search."
-                    )
-                elif (
-                    not isinstance(past_key_values[0], (tuple, tf.Tensor))
-                    or past_key_values[0][0].shape[0] != batch_size
-                ):
-                    raise ValueError(
-                        f"{self.__class__.__name__} does not have a standard cache format and therefore **can't** be "
-                        "used for contrastive search without further modifications."
-                    )
-            else:
-                logit_for_next_step = next_step_cached_variables["logit_for_next_step"]
-                last_hidden_states = next_step_cached_variables["last_hidden_states"]
-                outputs = next_step_cached_variables["outputs"]
-
-            # contrastive_search main logic start:
-            # contrastive search decoding consists of two steps: (1) candidate tokens recall; (2) candidate re-rank by
-            # degeneration penalty
-
-            logit_for_next_step = logits_processor(generated, logit_for_next_step, cur_len)
-            logit_for_next_step = logits_warper(generated, logit_for_next_step, cur_len)
-            next_probs = stable_softmax(logit_for_next_step, axis=-1)
-            top_k_probs, top_k_ids = tf.math.top_k(next_probs, k=top_k)
-
-            # Store scores, attentions and hidden_states when required
-            if not use_xla and return_dict_in_generate:
-                if output_scores:
-                    scores.append(logit_for_next_step)
-                if output_attentions and self.config.is_encoder_decoder:
-                    decoder_attentions.append(outputs.decoder_attentions)
-                elif output_attentions and not self.config.is_encoder_decoder:
-                    decoder_attentions.append(outputs.attentions)
-                    if self.config.is_encoder_decoder:
-                        cross_attentions.append(outputs.cross_attentions)
-
-                if output_hidden_states and self.config.is_encoder_decoder:
-                    decoder_hidden_states.append(outputs.decoder_hidden_states)
-                elif output_hidden_states and self.config.is_encoder_decoder:
-                    decoder_hidden_states.append(outputs.hidden_states)
-
-            # Replicates the new past_key_values to match the `top_k` candidates
-            model_kwargs["past_key_values"] = tf.nest.map_structure(
-                lambda tensor: tf.repeat(tensor, top_k, axis=cache_batch_axis), model_kwargs["past_key_values"]
-            )
-
-            # compute the candidate tokens by the language model and collects their hidden_states
-            next_model_inputs = self.prepare_inputs_for_generation(
-                tf.reshape(top_k_ids, [-1, 1]), use_cache=use_cache, **model_kwargs
-            )
-            outputs = self(
-                **next_model_inputs, return_dict=True, output_hidden_states=True, output_attentions=output_attentions
-            )
-            next_past_key_values = self._extract_past_from_model_output(outputs)
-
-            logits = outputs.logits[:, -1, :]
-            # name is different for encoder-decoder and decoder-only models
-            if self.config.is_encoder_decoder:
-                next_hidden = outputs.decoder_hidden_states[-1]
-                full_hidden_states = outputs.decoder_hidden_states
-            else:
-                next_hidden = outputs.hidden_states[-1]
-                full_hidden_states = outputs.hidden_states
-            context_hidden = tf.repeat(last_hidden_states[:, :cur_len, :], top_k, axis=0)
-
-            # compute the degeneration penalty and re-rank the candidates based on the degeneration penalty and the
-            # model confidence
-            selected_idx = _ranking_fast(context_hidden, next_hidden, top_k_probs, penalty_alpha, top_k)
-
-            # converts indices to a dimension of top_k to the stacked top_k * batch_size dimension, for indexing
-            # without a need to reshape on tensors that have these two dimensions stacked
-            selected_idx_stacked = selected_idx + tf.range(selected_idx.shape[0], dtype=tf.int64) * top_k
-
-            # prepare for the next step: (1) next token_id; (2) past_key_values; (3) last_hidden_states for computing
-            # the degeneration penalty; (4) logits for selecting next top-k candidates; (5) selected tokens scores
-            # (model confidence minus degeneration penalty); (6) decoder hidden_states
-            next_tokens = tf.gather(top_k_ids, selected_idx, axis=1, batch_dims=1)
-            next_hidden = gather_best_candidate(next_hidden, selected_idx_stacked)
-
-            # XLA: last_hidden_states normally grows at each step, but in XLA it is padded so as to be used across
-            # iterations (with fixed shapes)
-            if use_xla:
-                last_hidden_states = dynamic_update_slice(last_hidden_states, next_hidden, [0, cur_len, 0])
-            else:
-                last_hidden_states = tf.concat([last_hidden_states, next_hidden], axis=1)
-
-            next_decoder_hidden_states = gather_best_candidate(full_hidden_states, selected_idx_stacked)
-            next_past_key_values = gather_best_candidate(
-                next_past_key_values, selected_idx_stacked, batch_axis=cache_batch_axis
-            )
-            logit_for_next_step = gather_best_candidate(logits, selected_idx_stacked)
-
-            # Rebuilds the relevant parts of the model output for the selected token, for use in the next iteration
-            if self.config.is_encoder_decoder:
-                next_step_cross_attentions = ()
-                next_step_decoder_attentions = ()
-                if output_attentions:
-                    next_step_cross_attentions = gather_best_candidate(outputs.cross_attentions, selected_idx_stacked)
-                    next_step_decoder_attentions = gather_best_candidate(
-                        outputs.decoder_attentions, selected_idx_stacked
-                    )
-                outputs = TFSeq2SeqLMOutput(
-                    past_key_values=next_past_key_values,
-                    decoder_hidden_states=next_decoder_hidden_states,
-                    decoder_attentions=next_step_decoder_attentions or None,
-                    cross_attentions=next_step_cross_attentions or None,
-                )
-            else:
-                next_step_attentions = ()
-                if output_attentions:
-                    next_step_attentions = gather_best_candidate(outputs.attentions, selected_idx_stacked)
-                outputs = TFCausalLMOutputWithPast(
-                    past_key_values=next_past_key_values,
-                    hidden_states=next_decoder_hidden_states,
-                    attentions=next_step_attentions or None,
-                )
-            # contrastive_search main logic end
-
-            if eos_token_id is not None:
-                if pad_token_id is None:
-                    raise ValueError("If `eos_token_id` is defined, make sure that `pad_token_id` is defined.")
-                unfinished_seq = 1 - tf.cast(finished_sequences, tf.int32)
-                next_tokens = next_tokens * unfinished_seq + pad_token_id * (1 - unfinished_seq)
-                next_token_is_eos = tf.math.reduce_any(
-                    tf.equal(
-                        tf.broadcast_to(next_tokens, (len(eos_token_id), batch_size)), tf.expand_dims(eos_token_id, -1)
-                    ),
-                    axis=0,
-                )
-                finished_sequences = finished_sequences | next_token_is_eos
-
-            # update `generated` and `cur_len`
-            update_indices = tf.stack([tf.range(batch_size), tf.broadcast_to(cur_len, [batch_size])], axis=-1)
-            generated = tf.tensor_scatter_nd_update(tensor=generated, indices=update_indices, updates=next_tokens)
-            cur_len += 1
-
-            if use_xla:
-                # NOTE: 1) relative to other generation strategies, contrastive search is always running forward
-                # passes one step ahead -- hence the `cur_len=cur_len + 1`; 2) the attention mask here is expanded from
-                # [batch_size, ...] to [batch_size*top_k, ...] -- hence the `batch_size=batch_size * top_k`
-                model_kwargs = self._update_model_kwargs_for_xla_generation(
-                    model_outputs=outputs,
-                    model_kwargs=model_kwargs,
-                    cur_len=cur_len + 1,
-                    max_length=max_length,
-                    batch_size=batch_size * top_k,
-                    is_encoder_decoder=self.config.is_encoder_decoder,
-                    batch_axis=cache_batch_axis,
-                )
-            else:
-                model_kwargs = self._update_model_kwargs_for_generation(
-                    outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
-                )
-
-            next_step_cached_variables = {
-                "logit_for_next_step": logit_for_next_step,
-                "last_hidden_states": last_hidden_states,
-                "outputs": outputs,
-            }
-            return generated, finished_sequences, cur_len, model_kwargs, next_step_cached_variables
-
-        # 5. run generation
-        # 1st generation step has to be run before to initialize `past_key_values`
-        generated, finished_sequences, cur_len, model_kwargs, next_step_cached_variables = contrastive_search_body_fn(
-            generated, finished_sequences, cur_len, model_kwargs, None
-        )
-
-        # 2-to-n generation steps can then be run in autoregressive fashion
-        # only in case 1st generation step does NOT yield EOS token though
-        maximum_iterations = max_length - cur_len
-        generated, _, cur_len, _, _ = tf.while_loop(
-            contrastive_search_cond_fn,
-            contrastive_search_body_fn,
-            (generated, finished_sequences, cur_len, model_kwargs, next_step_cached_variables),
-            maximum_iterations=maximum_iterations,
-        )
-
-        # 6. prepare outputs
-        if not use_xla:
-            # cut for backward compatibility
-            generated = generated[:, :cur_len]
-
-        if return_dict_in_generate:
-            if self.config.is_encoder_decoder:
-                # if model is an encoder-decoder, retrieve encoder attention weights
-                # and hidden states
-                encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
-                encoder_hidden_states = (
-                    model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
-                )
-
-                scores = tuple(scores) if scores is not None else None
-                decoder_attentions = tuple(decoder_attentions) if decoder_attentions is not None else None
-                cross_attentions = tuple(cross_attentions) if cross_attentions is not None else None
-                decoder_hidden_states = tuple(decoder_hidden_states) if decoder_hidden_states is not None else None
-
-                return TFContrastiveSearchEncoderDecoderOutput(
-                    sequences=generated,
-                    scores=scores,
-                    encoder_attentions=encoder_attentions,
-                    encoder_hidden_states=encoder_hidden_states,
-                    decoder_attentions=decoder_attentions,
-                    cross_attentions=cross_attentions,
-                    decoder_hidden_states=decoder_hidden_states,
-                )
-            else:
-                return TFContrastiveSearchDecoderOnlyOutput(
-                    sequences=generated,
-                    scores=scores,
-                    attentions=decoder_attentions,
-                    hidden_states=decoder_hidden_states,
-                )
-        else:
-            return generated
-
-
-def tf_top_k_top_p_filtering(logits, top_k=0, top_p=1.0, filter_value=-float("Inf"), min_tokens_to_keep=1):
-    """
-    Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
-
-    Args:
-        logits: logits distribution shape (batch size, vocabulary size)
-        top_k (`int`, *optional*, defaults to 0):
-            If > 0, only keep the top k tokens with highest probability (top-k filtering)
-        top_p (`float`, *optional*, defaults to 1.0):
-            If < 1.0, only keep the top tokens with cumulative probability >= top_p (nucleus filtering). Nucleus
-            filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
-        min_tokens_to_keep (`int`, *optional*, defaults to 1):
-            Minimumber of tokens we keep per batch example in the output.
-
-    From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
-    """
-    logits_shape = shape_list(logits)
-
-    if top_k > 0:
-        top_k = min(max(top_k, min_tokens_to_keep), logits_shape[-1])  # Safety check
-        # Remove all tokens with a probability less than the last token of the top-k
-        indices_to_remove = logits < tf.math.top_k(logits, k=top_k)[0][..., -1, None]
-        logits = tf.where(indices_to_remove, filter_value, logits)
-    if top_p < 1.0:
-        sorted_indices = tf.argsort(logits, direction="DESCENDING")
-        sorted_logits = tf.gather(
-            logits, sorted_indices, axis=-1, batch_dims=1
-        )  # expects logits to be of dim (batch_size, vocab_size)
-
-        cumulative_probs = tf.math.cumsum(stable_softmax(sorted_logits, axis=-1), axis=-1)
-
-        # Remove tokens with cumulative probability above the threshold (token with 0 are kept)
-        sorted_indices_to_remove = cumulative_probs > top_p
-
-        if min_tokens_to_keep > 1:
-            # Keep at least min_tokens_to_keep (set to min_tokens_to_keep-1 because we add the first one below)
-            sorted_indices_to_remove = tf.concat(
-                [
-                    tf.zeros_like(sorted_indices_to_remove[:, :min_tokens_to_keep]),
-                    sorted_indices_to_remove[:, min_tokens_to_keep:],
-                ],
-                -1,
-            )
-
-        # Shift the indices to the right to keep also the first token above the threshold
-        sorted_indices_to_remove = tf.concat(
-            [tf.zeros_like(sorted_indices_to_remove[:, :1]), sorted_indices_to_remove[:, :-1]],
-            -1,
-        )
-        # scatter sorted tensors to original indexing
-        indices_to_remove = scatter_values_on_batch_indices(sorted_indices_to_remove, sorted_indices)
-        logits = tf.where(indices_to_remove, filter_value, logits)
-    return logits
-
-
-def scatter_values_on_batch_indices(values, batch_indices):
-    shape = shape_list(batch_indices)
-    # broadcast batch dim to shape
-    broad_casted_batch_dims = tf.reshape(tf.broadcast_to(tf.expand_dims(tf.range(shape[0]), axis=-1), shape), [1, -1])
-    # transform batch_indices to pair_indices
-    pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0))
-    # scatter values to pair indices
-    return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), shape)
-
-
-def sample_without_replacement(logits, num_samples):
-    """
-    categorical sampling without replacement is currently not implemented the gumbel-max trick will do for now see
-    https://github.com/tensorflow/tensorflow/issues/9260 for more info
-    """
-    z = -tf.math.log(-tf.math.log(tf.random.uniform(shape_list(logits), 0, 1)))
-    _, indices = tf.nn.top_k(logits + z, num_samples)
-    return indices
-
-
-def _ranking_fast(
-    context_hidden: tf.Tensor,
-    next_hidden: tf.Tensor,
-    next_top_k_probs: tf.Tensor,
-    alpha: float,
-    beam_width: int,
-) -> tf.Tensor:
-    """
-    Reranks the top_k candidates based on a degeneration penalty (cosine similarity with previous tokens), as described
-    in the paper "A Contrastive Framework for Neural Text Generation". Returns the index of the best candidate for each
-    row in the batch.
-    """
-    norm_context_hidden = context_hidden / tf.norm(context_hidden, axis=2, keepdims=True)
-    norm_next_hidden = next_hidden / tf.norm(next_hidden, axis=2, keepdims=True)
-    cosine_matrix = tf.squeeze(tf.linalg.matmul(norm_context_hidden, norm_next_hidden, transpose_b=True), axis=-1)
-    degeneration_penalty = tf.reduce_max(cosine_matrix, axis=-1)
-    next_top_k_probs = tf.reshape(next_top_k_probs, shape=[-1])
-    contrastive_score = (1.0 - alpha) * next_top_k_probs - alpha * degeneration_penalty
-    contrastive_score = tf.reshape(contrastive_score, shape=[-1, beam_width])
-    selected_idx = tf.argmax(contrastive_score, axis=1)
-    return selected_idx
diff --git a/spaces/yizhangliu/Grounded-Segment-Anything/transformers_4_35_0/models/maskformer/__init__.py b/spaces/yizhangliu/Grounded-Segment-Anything/transformers_4_35_0/models/maskformer/__init__.py
deleted file mode 100644
index efb2290f2c9ceb826e3902a9af7dd22a85f884ec..0000000000000000000000000000000000000000
--- a/spaces/yizhangliu/Grounded-Segment-Anything/transformers_4_35_0/models/maskformer/__init__.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# Copyright 2022 The HuggingFace Team. 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.
-from typing import TYPE_CHECKING
-
-from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available
-
-
-_import_structure = {
-    "configuration_maskformer": ["MASKFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "MaskFormerConfig"],
-    "configuration_maskformer_swin": ["MaskFormerSwinConfig"],
-}
-
-try:
-    if not is_vision_available():
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    pass
-else:
-    _import_structure["feature_extraction_maskformer"] = ["MaskFormerFeatureExtractor"]
-    _import_structure["image_processing_maskformer"] = ["MaskFormerImageProcessor"]
-
-
-try:
-    if not is_torch_available():
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    pass
-else:
-    _import_structure["modeling_maskformer"] = [
-        "MASKFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
-        "MaskFormerForInstanceSegmentation",
-        "MaskFormerModel",
-        "MaskFormerPreTrainedModel",
-    ]
-    _import_structure["modeling_maskformer_swin"] = [
-        "MaskFormerSwinBackbone",
-        "MaskFormerSwinModel",
-        "MaskFormerSwinPreTrainedModel",
-    ]
-
-if TYPE_CHECKING:
-    from .configuration_maskformer import MASKFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, MaskFormerConfig
-    from .configuration_maskformer_swin import MaskFormerSwinConfig
-
-    try:
-        if not is_vision_available():
-            raise OptionalDependencyNotAvailable()
-    except OptionalDependencyNotAvailable:
-        pass
-    else:
-        from .feature_extraction_maskformer import MaskFormerFeatureExtractor
-        from .image_processing_maskformer import MaskFormerImageProcessor
-    try:
-        if not is_torch_available():
-            raise OptionalDependencyNotAvailable()
-    except OptionalDependencyNotAvailable:
-        pass
-    else:
-        from .modeling_maskformer import (
-            MASKFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
-            MaskFormerForInstanceSegmentation,
-            MaskFormerModel,
-            MaskFormerPreTrainedModel,
-        )
-        from .modeling_maskformer_swin import (
-            MaskFormerSwinBackbone,
-            MaskFormerSwinModel,
-            MaskFormerSwinPreTrainedModel,
-        )
-
-
-else:
-    import sys
-
-    sys.modules[__name__] = _LazyModule(__name__, globals()["__file__"], _import_structure)
diff --git a/spaces/ynhe/AskAnything/models/grit_src/third_party/CenterNet2/docs/tutorials/builtin_datasets.md b/spaces/ynhe/AskAnything/models/grit_src/third_party/CenterNet2/docs/tutorials/builtin_datasets.md
deleted file mode 100644
index 0ba82423ad498bdd86274ada56a201134a590d94..0000000000000000000000000000000000000000
--- a/spaces/ynhe/AskAnything/models/grit_src/third_party/CenterNet2/docs/tutorials/builtin_datasets.md
+++ /dev/null
@@ -1 +0,0 @@
-../../datasets/README.md
\ No newline at end of file
diff --git a/spaces/yongjae/whisper-webui/tests/segments_test.py b/spaces/yongjae/whisper-webui/tests/segments_test.py
deleted file mode 100644
index d829f1c77f74b3c96513fe4965d532cf2d1dceb4..0000000000000000000000000000000000000000
--- a/spaces/yongjae/whisper-webui/tests/segments_test.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import sys
-import unittest
-
-sys.path.append('../whisper-webui')
-
-from src.segments import merge_timestamps
-
-class TestSegments(unittest.TestCase):
-    def __init__(self, *args, **kwargs):
-        super(TestSegments, self).__init__(*args, **kwargs)
-        
-    def test_merge_segments(self):
-        segments = [
-            {'start': 10.0, 'end': 20.0},
-            {'start': 22.0, 'end': 27.0},
-            {'start': 31.0, 'end': 35.0},
-            {'start': 45.0, 'end': 60.0},
-            {'start': 61.0, 'end': 65.0},
-            {'start': 68.0, 'end': 98.0},
-            {'start': 100.0, 'end': 102.0},
-            {'start': 110.0, 'end': 112.0}
-        ]
-
-        result = merge_timestamps(segments, merge_window=5, max_merge_size=30, padding_left=1, padding_right=1)
-
-        self.assertListEqual(result, [
-            {'start': 9.0, 'end': 36.0},
-            {'start': 44.0, 'end': 66.0},
-            {'start': 67.0, 'end': 99.0},
-            {'start': 99.0, 'end': 103.0},
-            {'start': 109.0, 'end': 113.0}
-        ])
-
-    def test_overlap_next(self):
-        segments = [
-            {'start': 5.0, 'end': 39.182},
-            {'start': 39.986, 'end': 40.814}
-        ]
-
-        result = merge_timestamps(segments, merge_window=5, max_merge_size=30, padding_left=1, padding_right=1)
-
-        self.assertListEqual(result, [
-            {'start': 4.0, 'end': 39.584},
-            {'start': 39.584, 'end': 41.814}
-        ])
-
-if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
diff --git a/spaces/yoon-gu/pokemon-quiz/make_evolve_dataset.py b/spaces/yoon-gu/pokemon-quiz/make_evolve_dataset.py
deleted file mode 100644
index 97940912c58b6b80fdefaa0864d1f8b3384a55ff..0000000000000000000000000000000000000000
--- a/spaces/yoon-gu/pokemon-quiz/make_evolve_dataset.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import urllib.request
-import re
-import json
-import urllib.parse
-from urllib.parse import urlsplit, quote
-from urllib.request import Request, urlopen
-from bs4 import BeautifulSoup
-from tqdm import tqdm
-import pandas as pd
-
-url = 'https://pokemon.fandom.com/ko/wiki/이상해씨_(포켓몬)'
-
-url_info = urlsplit(url)
-encoded_url = f'{url_info.scheme}://{url_info.netloc}{quote(url_info.path)}'
-
-info = []
-erros = []
-target_number = 1017
-cnt = 0
-for _ in tqdm(range(target_number+2)):
-    cnt += 1
-    req = Request(encoded_url, headers={'User-Agent': 'Mozilla/5.0'})
-    res = urlopen(req)
-    html = res.read()
-    soup = BeautifulSoup(html, 'html.parser')
-
-    name = soup.find("div", {"class": "name-ko"}).text.strip()
-    number = soup.find("div", {"class": "index"}).text.strip()
-    doc_text = '\n'.join([p.text.replace('\n', '').strip() for p in soup.find_all("p")])
-    types = [poke_type['title'].split(' ')[0].strip() for poke_type in soup.select('tbody > tr > td > div')[0].select('span > a')]
-
-    evol_tables = soup.find("table", style=re.compile("^margin:auto; text-align:center;"))
-    info.append(dict(name=name, evolve=[e.span.text for e in evol_tables.find_all("table")]))
-    next_monster = soup.find("table").findAll("a")[-1]['href']
-    encoded_url = "https://pokemon.fandom.com" + next_monster
-    if number == f"No.{target_number:04d}":
-        break
-
-    if cnt >= target_number:
-        break
-
-with open('pokemon_evolve.json', 'w') as f:
-    json.dump(info, f, ensure_ascii=False, indent=4)
\ No newline at end of file
diff --git a/spaces/younker/chatgpt-turbo/client/node_modules/autoprefixer/lib/hacks/align-items.js b/spaces/younker/chatgpt-turbo/client/node_modules/autoprefixer/lib/hacks/align-items.js
deleted file mode 100644
index 601a2d4813b6ab916b412471367559a4302dd118..0000000000000000000000000000000000000000
--- a/spaces/younker/chatgpt-turbo/client/node_modules/autoprefixer/lib/hacks/align-items.js
+++ /dev/null
@@ -1,46 +0,0 @@
-let flexSpec = require('./flex-spec')
-let Declaration = require('../declaration')
-
-class AlignItems extends Declaration {
-  /**
-   * Change property name for 2009 and 2012 specs
-   */
-  prefixed(prop, prefix) {
-    let spec
-    ;[spec, prefix] = flexSpec(prefix)
-    if (spec === 2009) {
-      return prefix + 'box-align'
-    }
-    if (spec === 2012) {
-      return prefix + 'flex-align'
-    }
-    return super.prefixed(prop, prefix)
-  }
-
-  /**
-   * Return property name by final spec
-   */
-  normalize() {
-    return 'align-items'
-  }
-
-  /**
-   * Change value for 2009 and 2012 specs
-   */
-  set(decl, prefix) {
-    let spec = flexSpec(prefix)[0]
-    if (spec === 2009 || spec === 2012) {
-      decl.value = AlignItems.oldValues[decl.value] || decl.value
-    }
-    return super.set(decl, prefix)
-  }
-}
-
-AlignItems.names = ['align-items', 'flex-align', 'box-align']
-
-AlignItems.oldValues = {
-  'flex-end': 'end',
-  'flex-start': 'start'
-}
-
-module.exports = AlignItems
diff --git a/spaces/yusendai/fnlp-moss-moon-003-sft-plugin/app.py b/spaces/yusendai/fnlp-moss-moon-003-sft-plugin/app.py
deleted file mode 100644
index 2734dc8611c9753982178e262163a5856097c8cd..0000000000000000000000000000000000000000
--- a/spaces/yusendai/fnlp-moss-moon-003-sft-plugin/app.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import gradio as gr
-from transformers import AutoModel, AutoTokenizer
-
-tokenizer = AutoTokenizer.from_pretrained("fnlp/moss-moon-003-sft-plugin", trust_remote_code=True)
-model = AutoModel.from_pretrained("fnlp/moss-moon-003-sft-plugin", trust_remote_code=True).half().cuda()
-model = model.eval()
-
-def predict(input, history=None):
-    if history is None:
-        history = []
-    prompt = ""
-    for (q, r) in history:
-        prompt += "<|Human|>: " + q + "<eoh>\n"
-        prompt += "<|MOSS|>: " + r + "\n"
-    prompt += "<|Human|>: " + input + "<eoh>\n<|MOSS|>:"
-    inputs = tokenizer(prompt, return_tensors="pt")
-    outputs = model.generate(**inputs, do_sample=True, temperature=0.7, top_p=0.8, repetition_penalty=1.1, max_new_tokens=512)
-    response = tokenizer.decode(outputs[0])
-    completion = response[len(prompt)+2:]
-    history = history + [(input, completion)]
-    return history, history
-
-
-with gr.Blocks() as demo:
-    gr.Markdown("moss-moon-003-sft-plugin")
-    state = gr.State([])
-    chatbot = gr.Chatbot([], elem_id="chatbot").style(height=400)
-    with gr.Row():
-        with gr.Column(scale=4):
-            txt = gr.Textbox(show_label=False, placeholder="Enter text and press enter").style(container=False)
-        with gr.Column(scale=1):
-            button = gr.Button("Generate")
-    txt.submit(predict, [txt, state], [chatbot, state])
-    button.click(predict, [txt, state], [chatbot, state])
-demo.queue().launch()
\ No newline at end of file
diff --git a/spaces/zestyoreo/vtryon/util/flow_util.py b/spaces/zestyoreo/vtryon/util/flow_util.py
deleted file mode 100644
index 78363b0b30fa10cd4d26eaa5a2fa03b9f1767778..0000000000000000000000000000000000000000
--- a/spaces/zestyoreo/vtryon/util/flow_util.py
+++ /dev/null
@@ -1,297 +0,0 @@
-import numpy as np
-import os
-import imageio
-import math
-import torch
-import importlib
-import re
-import argparse
-from natsort import natsorted
-
-
-
-# convert a tensor into a numpy array
-def tensor2im(image_tensor, bytes=255.0, imtype=np.uint8):
-    if image_tensor.dim() == 3:
-        image_numpy = image_tensor.cpu().float().numpy()
-    else:
-        image_numpy = image_tensor[0].cpu().float().numpy()
-    image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0 * bytes
-
-    return image_numpy.astype(imtype)
-
-
-# conver a tensor into a numpy array
-def tensor2array(value_tensor):
-    if value_tensor.dim() == 3:
-        numpy = value_tensor.view(-1).cpu().float().numpy()
-    else:
-        numpy = value_tensor[0].view(-1).cpu().float().numpy()
-    return numpy
-
-# label color map
-def uint82bin(n, count=8):
-    """returns the binary of integer n, count refers to amount of bits"""
-    return ''.join([str((n >> y) & 1) for y in range(count-1, -1, -1)])
-    
-def labelcolormap(N):
-    if N == 19: # CelebAMask-HQ
-        cmap = np.array([(0,  0,  0), (204, 0,  0), (76, 153, 0),
-                     (204, 204, 0), (51, 51, 255), (204, 0, 204), (0, 255, 255),
-                     (51, 255, 255), (102, 51, 0), (255, 0, 0), (102, 204, 0),
-                     (255, 255, 0), (0, 0, 153), (0, 0, 204), (255, 51, 153), 
-                     (0, 204, 204), (0, 51, 0), (255, 153, 51), (0, 204, 0)], 
-                     dtype=np.uint8) 
-    else:
-        cmap = np.zeros((N, 3), dtype=np.uint8)
-        for i in range(N):
-            r, g, b = 0, 0, 0
-            id = i
-            for j in range(7):
-                str_id = uint82bin(id)
-                r = r ^ (np.uint8(str_id[-1]) << (7-j))
-                g = g ^ (np.uint8(str_id[-2]) << (7-j))
-                b = b ^ (np.uint8(str_id[-3]) << (7-j))
-                id = id >> 3
-            cmap[i, 0] = r
-            cmap[i, 1] = g
-            cmap[i, 2] = b
-    return cmap
-
-class Colorize(object):
-    def __init__(self, n):
-        self.cmap = labelcolormap(n)
-        self.cmap = torch.from_numpy(self.cmap[:n])
-
-    def __call__(self, gray_image):
-        if len(gray_image.size()) != 3:
-            gray_image = gray_image[0]
-            
-        size = gray_image.size()
-        color_image = torch.ByteTensor(3, size[1], size[2]).fill_(0)
-
-        for label in range(0, len(self.cmap)):
-            mask = (label == gray_image[0]).cpu()
-            color_image[0][mask] = self.cmap[label][0]
-            color_image[1][mask] = self.cmap[label][1]
-            color_image[2][mask] = self.cmap[label][2]
-        color_image = color_image.float()/255.0 * 2 - 1
-        return color_image    
-
-
-def make_colorwheel():
-        '''
-        Generates a color wheel for optical flow visualization as presented in:
-            Baker et al. "A Database and Evaluation Methodology for Optical Flow" (ICCV, 2007)
-            URL: http://vision.middlebury.edu/flow/flowEval-iccv07.pdf
-        According to the C++ source code of Daniel Scharstein
-        According to the Matlab source code of Deqing Sun
-        '''
-        RY = 15
-        YG = 6
-        GC = 4
-        CB = 11
-        BM = 13
-        MR = 6
-
-        ncols = RY + YG + GC + CB + BM + MR
-        colorwheel = np.zeros((ncols, 3))
-        col = 0
-
-        # RY
-        colorwheel[0:RY, 0] = 255
-        colorwheel[0:RY, 1] = np.floor(255*np.arange(0,RY)/RY)
-        col = col+RY
-        # YG
-        colorwheel[col:col+YG, 0] = 255 - np.floor(255*np.arange(0,YG)/YG)
-        colorwheel[col:col+YG, 1] = 255
-        col = col+YG
-        # GC
-        colorwheel[col:col+GC, 1] = 255
-        colorwheel[col:col+GC, 2] = np.floor(255*np.arange(0,GC)/GC)
-        col = col+GC
-        # CB
-        colorwheel[col:col+CB, 1] = 255 - np.floor(255*np.arange(CB)/CB)
-        colorwheel[col:col+CB, 2] = 255
-        col = col+CB
-        # BM
-        colorwheel[col:col+BM, 2] = 255
-        colorwheel[col:col+BM, 0] = np.floor(255*np.arange(0,BM)/BM)
-        col = col+BM
-        # MR
-        colorwheel[col:col+MR, 2] = 255 - np.floor(255*np.arange(MR)/MR)
-        colorwheel[col:col+MR, 0] = 255
-        return colorwheel
-
-
-class flow2color():
-# code from: https://github.com/tomrunia/OpticalFlow_Visualization
-# MIT License
-#
-# Copyright (c) 2018 Tom Runia
-#
-# 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 conditions.
-#
-# Author: Tom Runia
-# Date Created: 2018-08-03
-    def __init__(self):
-        self.colorwheel = make_colorwheel()
-
-
-    def flow_compute_color(self, u, v, convert_to_bgr=False):
-        '''
-        Applies the flow color wheel to (possibly clipped) flow components u and v.
-        According to the C++ source code of Daniel Scharstein
-        According to the Matlab source code of Deqing Sun
-        :param u: np.ndarray, input horizontal flow
-        :param v: np.ndarray, input vertical flow
-        :param convert_to_bgr: bool, whether to change ordering and output BGR instead of RGB
-        :return:
-        '''
-        flow_image = np.zeros((u.shape[0], u.shape[1], 3), np.uint8)
-        ncols = self.colorwheel.shape[0]
-
-        rad = np.sqrt(np.square(u) + np.square(v))
-        a = np.arctan2(-v, -u)/np.pi
-        fk = (a+1) / 2*(ncols-1)
-        k0 = np.floor(fk).astype(np.int32)
-        k1 = k0 + 1
-        k1[k1 == ncols] = 0
-        f = fk - k0
-
-        for i in range(self.colorwheel.shape[1]):
-
-            tmp = self.colorwheel[:,i]
-            col0 = tmp[k0] / 255.0
-            col1 = tmp[k1] / 255.0
-            col = (1-f)*col0 + f*col1
-
-            idx = (rad <= 1)
-            col[idx]  = 1 - rad[idx] * (1-col[idx])
-            col[~idx] = col[~idx] * 0.75   # out of range?
-
-            # Note the 2-i => BGR instead of RGB
-            ch_idx = 2-i if convert_to_bgr else i
-            flow_image[:,:,ch_idx] = np.floor(255 * col)
-
-        return flow_image
-
-
-    def __call__(self, flow_uv, clip_flow=None, convert_to_bgr=False):
-        '''
-        Expects a two dimensional flow image of shape [H,W,2]
-        According to the C++ source code of Daniel Scharstein
-        According to the Matlab source code of Deqing Sun
-        :param flow_uv: np.ndarray of shape [H,W,2]
-        :param clip_flow: float, maximum clipping value for flow
-        :return:
-        '''
-        if len(flow_uv.size()) != 3:
-            flow_uv = flow_uv[0]
-        flow_uv = flow_uv.permute(1,2,0).cpu().detach().numpy()    
-
-        assert flow_uv.ndim == 3, 'input flow must have three dimensions'
-        assert flow_uv.shape[2] == 2, 'input flow must have shape [H,W,2]'
-
-        if clip_flow is not None:
-            flow_uv = np.clip(flow_uv, 0, clip_flow)
-
-        u = flow_uv[:,:,1]
-        v = flow_uv[:,:,0]
-
-
-        rad = np.sqrt(np.square(u) + np.square(v))
-        rad_max = np.max(rad)
-
-        epsilon = 1e-5
-        u = u / (rad_max + epsilon)
-        v = v / (rad_max + epsilon)
-        image = self.flow_compute_color(u, v, convert_to_bgr) 
-        image = torch.tensor(image).float().permute(2,0,1)/255.0 * 2 - 1
-        return image
-
-
-def save_image(image_numpy, image_path):
-    if image_numpy.shape[2] == 1:
-        image_numpy = image_numpy.reshape(image_numpy.shape[0], image_numpy.shape[1])
-
-    imageio.imwrite(image_path, image_numpy)
-
-
-def mkdirs(paths):
-    if isinstance(paths, list) and not isinstance(paths, str):
-        for path in paths:
-            mkdir(path)
-    else:
-        mkdir(paths)
-
-
-def mkdir(path):
-    if not os.path.exists(path):
-        os.makedirs(path)
-
-
-def find_class_in_module(target_cls_name, module):
-    target_cls_name = target_cls_name.replace('_', '').lower()
-    clslib = importlib.import_module(module)
-    cls = None
-    for name, clsobj in clslib.__dict__.items():
-        if name.lower() == target_cls_name:
-            cls = clsobj
-
-    if cls is None:
-        print("In %s, there should be a class whose name matches %s in lowercase without underscore(_)" % (module, target_cls_name))
-        exit(0)
-
-    return cls        
-
-
-
-def atoi(text):
-    return int(text) if text.isdigit() else text
-
-
-def natural_keys(text):
-    '''
-    alist.sort(key=natural_keys) sorts in human order
-    http://nedbatchelder.com/blog/200712/human_sorting.html
-    (See Toothy's implementation in the comments)
-    '''
-    return [atoi(c) for c in re.split('(\d+)', text)]
-
-
-def natural_sort(items):
-    items.sort(key=natural_keys)    
-
-class StoreDictKeyPair(argparse.Action):
-     def __call__(self, parser, namespace, values, option_string=None):
-         my_dict = {}
-         for kv in values.split(","):
-             # print(kv)
-             k,v = kv.split("=")
-             my_dict[k] = int(v)
-         setattr(namespace, self.dest, my_dict)   
-
-class StoreList(argparse.Action):
-     def __call__(self, parser, namespace, values, option_string=None):
-        my_list = [int(item) for item in values.split(',')]
-        setattr(namespace, self.dest, my_list)   
-#           
-def get_iteration(dir_name, file_name, net_name):
-    if os.path.exists(os.path.join(dir_name, file_name)) is False:
-        return None
-    if 'latest' in file_name:
-        gen_models = [os.path.join(dir_name, f) for f in os.listdir(dir_name) if
-              os.path.isfile(os.path.join(dir_name, f)) and (not 'latest' in f) and ('_net_'+net_name+'.pth' in f)]
-        if gen_models == []:
-            return 0
-        model_name = os.path.basename(natsorted(gen_models)[-1])
-    else:
-        model_name = file_name
-    iterations = int(model_name.replace('_net_'+net_name+'.pth', ''))
-    return iterations
diff --git a/spaces/zhang-wei-jian/docker/node_modules/co/index.js b/spaces/zhang-wei-jian/docker/node_modules/co/index.js
deleted file mode 100644
index 87ba8ba8b40651d7e5194f8e0fecda856a6b360c..0000000000000000000000000000000000000000
--- a/spaces/zhang-wei-jian/docker/node_modules/co/index.js
+++ /dev/null
@@ -1,237 +0,0 @@
-
-/**
- * slice() reference.
- */
-
-var slice = Array.prototype.slice;
-
-/**
- * Expose `co`.
- */
-
-module.exports = co['default'] = co.co = co;
-
-/**
- * Wrap the given generator `fn` into a
- * function that returns a promise.
- * This is a separate function so that
- * every `co()` call doesn't create a new,
- * unnecessary closure.
- *
- * @param {GeneratorFunction} fn
- * @return {Function}
- * @api public
- */
-
-co.wrap = function (fn) {
-  createPromise.__generatorFunction__ = fn;
-  return createPromise;
-  function createPromise() {
-    return co.call(this, fn.apply(this, arguments));
-  }
-};
-
-/**
- * Execute the generator function or a generator
- * and return a promise.
- *
- * @param {Function} fn
- * @return {Promise}
- * @api public
- */
-
-function co(gen) {
-  var ctx = this;
-  var args = slice.call(arguments, 1)
-
-  // we wrap everything in a promise to avoid promise chaining,
-  // which leads to memory leak errors.
-  // see https://github.com/tj/co/issues/180
-  return new Promise(function(resolve, reject) {
-    if (typeof gen === 'function') gen = gen.apply(ctx, args);
-    if (!gen || typeof gen.next !== 'function') return resolve(gen);
-
-    onFulfilled();
-
-    /**
-     * @param {Mixed} res
-     * @return {Promise}
-     * @api private
-     */
-
-    function onFulfilled(res) {
-      var ret;
-      try {
-        ret = gen.next(res);
-      } catch (e) {
-        return reject(e);
-      }
-      next(ret);
-    }
-
-    /**
-     * @param {Error} err
-     * @return {Promise}
-     * @api private
-     */
-
-    function onRejected(err) {
-      var ret;
-      try {
-        ret = gen.throw(err);
-      } catch (e) {
-        return reject(e);
-      }
-      next(ret);
-    }
-
-    /**
-     * Get the next value in the generator,
-     * return a promise.
-     *
-     * @param {Object} ret
-     * @return {Promise}
-     * @api private
-     */
-
-    function next(ret) {
-      if (ret.done) return resolve(ret.value);
-      var value = toPromise.call(ctx, ret.value);
-      if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
-      return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, '
-        + 'but the following object was passed: "' + String(ret.value) + '"'));
-    }
-  });
-}
-
-/**
- * Convert a `yield`ed value into a promise.
- *
- * @param {Mixed} obj
- * @return {Promise}
- * @api private
- */
-
-function toPromise(obj) {
-  if (!obj) return obj;
-  if (isPromise(obj)) return obj;
-  if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
-  if ('function' == typeof obj) return thunkToPromise.call(this, obj);
-  if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
-  if (isObject(obj)) return objectToPromise.call(this, obj);
-  return obj;
-}
-
-/**
- * Convert a thunk to a promise.
- *
- * @param {Function}
- * @return {Promise}
- * @api private
- */
-
-function thunkToPromise(fn) {
-  var ctx = this;
-  return new Promise(function (resolve, reject) {
-    fn.call(ctx, function (err, res) {
-      if (err) return reject(err);
-      if (arguments.length > 2) res = slice.call(arguments, 1);
-      resolve(res);
-    });
-  });
-}
-
-/**
- * Convert an array of "yieldables" to a promise.
- * Uses `Promise.all()` internally.
- *
- * @param {Array} obj
- * @return {Promise}
- * @api private
- */
-
-function arrayToPromise(obj) {
-  return Promise.all(obj.map(toPromise, this));
-}
-
-/**
- * Convert an object of "yieldables" to a promise.
- * Uses `Promise.all()` internally.
- *
- * @param {Object} obj
- * @return {Promise}
- * @api private
- */
-
-function objectToPromise(obj){
-  var results = new obj.constructor();
-  var keys = Object.keys(obj);
-  var promises = [];
-  for (var i = 0; i < keys.length; i++) {
-    var key = keys[i];
-    var promise = toPromise.call(this, obj[key]);
-    if (promise && isPromise(promise)) defer(promise, key);
-    else results[key] = obj[key];
-  }
-  return Promise.all(promises).then(function () {
-    return results;
-  });
-
-  function defer(promise, key) {
-    // predefine the key in the result
-    results[key] = undefined;
-    promises.push(promise.then(function (res) {
-      results[key] = res;
-    }));
-  }
-}
-
-/**
- * Check if `obj` is a promise.
- *
- * @param {Object} obj
- * @return {Boolean}
- * @api private
- */
-
-function isPromise(obj) {
-  return 'function' == typeof obj.then;
-}
-
-/**
- * Check if `obj` is a generator.
- *
- * @param {Mixed} obj
- * @return {Boolean}
- * @api private
- */
-
-function isGenerator(obj) {
-  return 'function' == typeof obj.next && 'function' == typeof obj.throw;
-}
-
-/**
- * Check if `obj` is a generator function.
- *
- * @param {Mixed} obj
- * @return {Boolean}
- * @api private
- */
-function isGeneratorFunction(obj) {
-  var constructor = obj.constructor;
-  if (!constructor) return false;
-  if ('GeneratorFunction' === constructor.name || 'GeneratorFunction' === constructor.displayName) return true;
-  return isGenerator(constructor.prototype);
-}
-
-/**
- * Check for plain object.
- *
- * @param {Mixed} val
- * @return {Boolean}
- * @api private
- */
-
-function isObject(val) {
-  return Object == val.constructor;
-}
diff --git a/spaces/zhtet/RegBotBeta/utils/__init__.py b/spaces/zhtet/RegBotBeta/utils/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/zideliu/styledrop/open_clip/modified_resnet.py b/spaces/zideliu/styledrop/open_clip/modified_resnet.py
deleted file mode 100644
index f7c0b033a80e7d08a20a367050c5b1bc5d5292e7..0000000000000000000000000000000000000000
--- a/spaces/zideliu/styledrop/open_clip/modified_resnet.py
+++ /dev/null
@@ -1,181 +0,0 @@
-from collections import OrderedDict
-
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from open_clip.utils import freeze_batch_norm_2d
-
-
-class Bottleneck(nn.Module):
-    expansion = 4
-
-    def __init__(self, inplanes, planes, stride=1):
-        super().__init__()
-
-        # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1
-        self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
-        self.bn1 = nn.BatchNorm2d(planes)
-        self.act1 = nn.ReLU(inplace=True)
-
-        self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
-        self.bn2 = nn.BatchNorm2d(planes)
-        self.act2 = nn.ReLU(inplace=True)
-
-        self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()
-
-        self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
-        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
-        self.act3 = nn.ReLU(inplace=True)
-
-        self.downsample = None
-        self.stride = stride
-
-        if stride > 1 or inplanes != planes * Bottleneck.expansion:
-            # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1
-            self.downsample = nn.Sequential(OrderedDict([
-                ("-1", nn.AvgPool2d(stride)),
-                ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)),
-                ("1", nn.BatchNorm2d(planes * self.expansion))
-            ]))
-
-    def forward(self, x: torch.Tensor):
-        identity = x
-
-        out = self.act1(self.bn1(self.conv1(x)))
-        out = self.act2(self.bn2(self.conv2(out)))
-        out = self.avgpool(out)
-        out = self.bn3(self.conv3(out))
-
-        if self.downsample is not None:
-            identity = self.downsample(x)
-
-        out += identity
-        out = self.act3(out)
-        return out
-
-
-class AttentionPool2d(nn.Module):
-    def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None):
-        super().__init__()
-        self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5)
-        self.k_proj = nn.Linear(embed_dim, embed_dim)
-        self.q_proj = nn.Linear(embed_dim, embed_dim)
-        self.v_proj = nn.Linear(embed_dim, embed_dim)
-        self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
-        self.num_heads = num_heads
-
-    def forward(self, x):
-        x = x.reshape(x.shape[0], x.shape[1], x.shape[2] * x.shape[3]).permute(2, 0, 1)  # NCHW -> (HW)NC
-        x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)NC
-        x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)NC
-        x, _ = F.multi_head_attention_forward(
-            query=x, key=x, value=x,
-            embed_dim_to_check=x.shape[-1],
-            num_heads=self.num_heads,
-            q_proj_weight=self.q_proj.weight,
-            k_proj_weight=self.k_proj.weight,
-            v_proj_weight=self.v_proj.weight,
-            in_proj_weight=None,
-            in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
-            bias_k=None,
-            bias_v=None,
-            add_zero_attn=False,
-            dropout_p=0.,
-            out_proj_weight=self.c_proj.weight,
-            out_proj_bias=self.c_proj.bias,
-            use_separate_proj_weight=True,
-            training=self.training,
-            need_weights=False
-        )
-
-        return x[0]
-
-
-class ModifiedResNet(nn.Module):
-    """
-    A ResNet class that is similar to torchvision's but contains the following changes:
-    - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool.
-    - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1
-    - The final pooling layer is a QKV attention instead of an average pool
-    """
-
-    def __init__(self, layers, output_dim, heads, image_size=224, width=64):
-        super().__init__()
-        self.output_dim = output_dim
-        self.image_size = image_size
-
-        # the 3-layer stem
-        self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False)
-        self.bn1 = nn.BatchNorm2d(width // 2)
-        self.act1 = nn.ReLU(inplace=True)
-        self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False)
-        self.bn2 = nn.BatchNorm2d(width // 2)
-        self.act2 = nn.ReLU(inplace=True)
-        self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False)
-        self.bn3 = nn.BatchNorm2d(width)
-        self.act3 = nn.ReLU(inplace=True)
-        self.avgpool = nn.AvgPool2d(2)
-
-        # residual layers
-        self._inplanes = width  # this is a *mutable* variable used during construction
-        self.layer1 = self._make_layer(width, layers[0])
-        self.layer2 = self._make_layer(width * 2, layers[1], stride=2)
-        self.layer3 = self._make_layer(width * 4, layers[2], stride=2)
-        self.layer4 = self._make_layer(width * 8, layers[3], stride=2)
-
-        embed_dim = width * 32  # the ResNet feature dimension
-        self.attnpool = AttentionPool2d(image_size // 32, embed_dim, heads, output_dim)
-
-        self.init_parameters()
-
-    def _make_layer(self, planes, blocks, stride=1):
-        layers = [Bottleneck(self._inplanes, planes, stride)]
-
-        self._inplanes = planes * Bottleneck.expansion
-        for _ in range(1, blocks):
-            layers.append(Bottleneck(self._inplanes, planes))
-
-        return nn.Sequential(*layers)
-
-    def init_parameters(self):
-        if self.attnpool is not None:
-            std = self.attnpool.c_proj.in_features ** -0.5
-            nn.init.normal_(self.attnpool.q_proj.weight, std=std)
-            nn.init.normal_(self.attnpool.k_proj.weight, std=std)
-            nn.init.normal_(self.attnpool.v_proj.weight, std=std)
-            nn.init.normal_(self.attnpool.c_proj.weight, std=std)
-
-        for resnet_block in [self.layer1, self.layer2, self.layer3, self.layer4]:
-            for name, param in resnet_block.named_parameters():
-                if name.endswith("bn3.weight"):
-                    nn.init.zeros_(param)
-
-    def lock(self, unlocked_groups=0, freeze_bn_stats=False):
-        assert unlocked_groups == 0, 'partial locking not currently supported for this model'
-        for param in self.parameters():
-            param.requires_grad = False
-        if freeze_bn_stats:
-            freeze_batch_norm_2d(self)
-
-    @torch.jit.ignore
-    def set_grad_checkpointing(self, enable=True):
-        # FIXME support for non-transformer
-        pass
-
-    def stem(self, x):
-        x = self.act1(self.bn1(self.conv1(x)))
-        x = self.act2(self.bn2(self.conv2(x)))
-        x = self.act3(self.bn3(self.conv3(x)))
-        x = self.avgpool(x)
-        return x
-
-    def forward(self, x):
-        x = self.stem(x)
-        x = self.layer1(x)
-        x = self.layer2(x)
-        x = self.layer3(x)
-        x = self.layer4(x)
-        x = self.attnpool(x)
-
-        return x