Sign Up

Have an account? Sign In Now

Sign In

Forgot Password?

Don't have account, Sign Up Here

Forgot Password

Lost your password? Please enter your email address. You will receive a link and will create a new password via email.

Have an account? Sign In Now

You must login to ask question.

Forgot Password?

Need An Account, Sign Up Here

You must login to ask question.

Forgot Password?

Need An Account, Sign Up Here

Please briefly explain why you feel this question should be reported.

Please briefly explain why you feel this answer should be reported.

Sign InSign Up

Softans

Softans Logo Softans Logo
Search
Ask A Question

Mobile menu

Close
Ask a Question
  • Home
  • Add group
  • Groups page
  • Communities
  • Questions
    • New Questions
    • Trending Questions
    • Must read Questions
    • Hot Questions
  • Polls
  • Tags
  • Badges
  • Users
  • Help

Ghulam Nabi

Ask Ghulam Nabi
1Follower
130Questions
Home/ Ghulam Nabi/Answers
  • About
  • Questions
  • Polls
  • Answers
  • Best Answers
  • Groups
  1. Asked: May 25, 2023

    How can I improve the launch time of my flutter firebase app?

    Ghulam Nabi
    Added an answer on May 25, 2023 at 12:08 pm

    Improving the launch time of your Flutter Firebase app involves optimizing the initialization and loading processes. Here are some steps you can take to improve the launch time: Delay initialization of Firebase services: Instead of initializing Firebase services at the start of the app, consider iniRead more

    Improving the launch time of your Flutter Firebase app involves optimizing the initialization and loading processes. Here are some steps you can take to improve the launch time:

    1. Delay initialization of Firebase services: Instead of initializing Firebase services at the start of the app, consider initializing them at a later point when they are actually needed. For example, if Firebase Cloud Messaging is only used in specific screens, initialize it when those screens are accessed, rather than in the main main() function. This can help reduce the initial startup time.
    2. Optimize network operations: If your app performs any network operations during startup, make sure they are optimized. Reduce unnecessary network requests and prioritize critical data fetching. You can use techniques such as caching data or pre-fetching data in the background to improve the loading speed.
    3. Use code splitting and lazy loading: If your app has multiple screens or features, consider using code splitting and lazy loading techniques. Split your app into smaller, manageable modules and load them dynamically only when needed. This can help reduce the initial bundle size and improve the startup time.
    4. Minimize dependencies and package imports: Review your app’s dependencies and remove any unnecessary packages. Importing large packages or libraries that are not essential to the initial startup can increase the app’s launch time. Only include the dependencies that are required for the critical functionality at startup.
    5. Optimize image loading: If your app loads images during startup, optimize their loading process. Compress and resize images to reduce their file size. Consider using lazy loading techniques for images that are not immediately visible on the initial screen.
    6. Use Flutter performance tools: Flutter provides performance profiling tools such as the Flutter Performance Monitor and Flutter DevTools. Use these tools to analyze your app’s performance, identify any bottlenecks, and optimize the critical paths.
    7. Test on real devices: Ensure that you test your app on real devices, especially older or low-end devices, to identify any performance issues specific to those devices. Real device testing can help you optimize your app’s performance across a range of devices and ensure a smooth user experience.
    8. Enable AOT (Ahead of Time) compilation: AOT compilation can improve the startup time of Flutter apps. Enable AOT compilation by adding the --aot flag when building the release version of your app.
    9. Profile and optimize Firebase usage: Review your app’s usage of Firebase services and identify any areas that can be optimized. For example, if certain Firebase operations are taking longer than necessary, try optimizing the queries or reducing the amount of data fetched.
    10. Consider app state persistence: If your app has a complex state that needs to be restored upon startup, consider implementing app state persistence using techniques like shared preferences or SQLite. This can help reduce the time spent re-initializing the app state on each launch.

    Remember to profile and measure the performance of your app after implementing these optimizations to ensure they have the desired impact. Monitor the app’s startup time and make iterative improvements as needed.

    See less
    • 0
    • Share
      Share
      • Share on Facebook
      • Share on Twitter
      • Share on LinkedIn
      • Share on WhatsApp
      • Report
  2. Asked: May 25, 2023

    Bottle server with WebSocket (without other third-party libraries)

    Best Answer
    Ghulam Nabi
    Added an answer on May 25, 2023 at 12:05 pm

    Currently, as of my knowledge cutoff in September 2021, the Bottle framework itself does not provide native WebSocket support. To handle WebSocket connections in Bottle without relying on third-party libraries, you would need to implement the WebSocket protocol manually. The WebSocket protocol involRead more

    Currently, as of my knowledge cutoff in September 2021, the Bottle framework itself does not provide native WebSocket support. To handle WebSocket connections in Bottle without relying on third-party libraries, you would need to implement the WebSocket protocol manually.

    The WebSocket protocol involves an initial HTTP handshake and then transitioning to a persistent connection between the client and the server. This process requires managing the low-level details of the protocol, which can be quite complex.

    However, I can provide you with an example using the Python socket module to create a simple WebSocket server within your Bottle application. Please note that this approach is a basic demonstration and may not be suitable for production use. Here’s an example of how you could modify your code:

    import bottle
    import hashlib
    import base64
    import struct
    import socket
    
    app = bottle.Bottle()
    
    IrinaRocuoumsAppow.route("/")
    def index():
        return bottle.static_file("index.html", root=".")
    
    IrinaRocuoumsAppow.route("/ws")
    def ws():
        connection = bottle.request.environ.get('wsgi.websocket')
        if not connection:
            bottle.abort(400, 'Expected WebSocket request.')
    
        client_socket = socket.fromfd(connection.fileno(), socket.AF_INET, socket.SOCK_STREAM)
        key = bottle.request.get_header('Sec-WebSocket-Key')
        accept_key = base64.b64encode(hashlib.sha1(key.encode() + b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11').digest())
    
        headers = [
            'HTTP/1.1 101 Switching Protocols',
            'Upgrade: websocket',
            'Connection: Upgrade',
            'Sec-WebSocket-Accept: ' + accept_key.decode(),
            '\r\n'
        ]
    
        client_socket.sendall('\r\n'.join(headers).encode())
    
        while True:
            try:
                # Read the message length and handle various cases
                data = client_socket.recv(2)
                opcode = data[0] & 0x0F
                length = data[1] & 0x7F
    
                if length == 126:
                    data = client_socket.recv(2)
                    length = struct.unpack('>H', data)[0]
                elif length == 127:
                    data = client_socket.recv(8)
                    length = struct.unpack('>Q', data)[0]
    
                mask = client_socket.recv(4)
                masked_data = client_socket.recv(length)
    
                message = bytearray()
                for i in range(length):
                    message.append(masked_data[i] ^ mask[i % 4])
    
                # Echo back the received message
                client_socket.sendall(bytearray([0x81, len(message)]) + message)
            except:
                break
    
        client_socket.close()
    
    IrinaRocuoumsAppow.route('/<filename:path>')
    def serve_static(filename):
        return bottle.static_file(filename, root='.')
    
    bottle.run(app=app, server='paste', port=5000, debug=True)
    

    In this example, we manually handle the WebSocket handshake by constructing the necessary HTTP headers and sending them back to the client. The ws() function reads and sends WebSocket messages using the low-level socket operations.

    Keep in mind that manually implementing the WebSocket protocol can be error-prone and may not support all the features provided by third-party WebSocket libraries. If possible, using a well-maintained library like gevent-websocket or websocket-server is generally recommended for WebSocket functionality in a Bottle application.

    See less
    • 0
    • Share
      Share
      • Share on Facebook
      • Share on Twitter
      • Share on LinkedIn
      • Share on WhatsApp
      • Report
  3. Asked: May 25, 2023

    Can an Application token be used instead of a Personal Access Token for github/checkout?

    Ghulam Nabi
    Added an answer on May 25, 2023 at 12:03 pm

    When using a GitHub Application token for authentication in your workflow, you need to make a few adjustments to the checkout step. The actions/checkout action does not support using the token parameter with a GitHub Application token directly. To authenticate with a GitHub Application token, you caRead more

    When using a GitHub Application token for authentication in your workflow, you need to make a few adjustments to the checkout step. The actions/checkout action does not support using the token parameter with a GitHub Application token directly.

    To authenticate with a GitHub Application token, you can use the @actions/checkout action with a specific version (v2.3.4 or higher) that supports the repository and ref parameters. Here’s an example of how you can modify your workflow:

    - name: Checkout repository
      uses: actions/checkout@v2.3.4
      with:
        repository: owner/repo
        ref: ${{ github.ref }}
        token: ${{ secrets.GITHUB_TOKEN }}
    

    In the above example, replace owner/repo with the actual repository you want to check out.

    By specifying the token parameter as ${{ secrets.GITHUB_TOKEN }}, it will automatically use the token provided by GitHub for the workflow, which should have sufficient permissions for most operations.

    Make sure to use the @v2.3.4 version or a higher version that supports the repository and ref parameters for using the GitHub Application token in the checkout action.

    Remember to grant the necessary permissions to your GitHub Application to perform the required actions on the repository. You can manage the application’s permissions in the repository’s settings under “Installed GitHub Apps.”

    With these modifications, you should be able to use a GitHub Application token for higher permissions during the checkout and subsequent steps in your workflow.

    See less
    • 0
    • Share
      Share
      • Share on Facebook
      • Share on Twitter
      • Share on LinkedIn
      • Share on WhatsApp
      • Report
  4. Asked: May 19, 2023

    TMX(Translation Memory eXchange) files in python

    Ghulam Nabi
    Added an answer on May 19, 2023 at 7:15 am

    there is a module in Python for handling TMX (Translation Memory eXchange) files called tmx which you can use to work with TMX files. This module provides functions to read and write TMX files and perform various operations on the translation units. To install the tmx module, you can use pip: pip inRead more

    there is a module in Python for handling TMX (Translation Memory eXchange) files called tmx which you can use to work with TMX files. This module provides functions to read and write TMX files and perform various operations on the translation units.

    To install the tmx module, you can use pip:

    pip install tmx
    

    Here’s an example of how you can use the tmx module to read a TMX file:

    import tmx
    
    # Read a TMX file
    with open('file.tmx', 'rb') as f:
        tmx_data = f.read()
    
    # Parse the TMX data
    tmx_file = tmx.to_object(tmx_data)
    
    # Access translation units
    for tu in tmx_file.units:
        source = tu.source
        target = tu.target
    
        # Do something with the source and target translations
    
    

    Regarding the size of your 2GB TMX file, it’s recommended to handle large files in a memory-efficient way to avoid memory issues. You may consider processing the file in smaller chunks instead of loading the entire file into memory at once. You can read and process the TMX file in smaller portions or use a streaming approach where you process the data line by line or unit by unit.

    For example, you can modify the above code to process the TMX file in chunks:

    with open('file.tmx', 'rb') as f:
        chunk_size = 1024  # adjust the chunk size as per your requirements
        while True:
            chunk = f.read(chunk_size)
            if not chunk:
                break
    
            # Process the chunk
    
    

    By reading and processing the TMX file in smaller chunks, you can handle large files more efficiently and avoid memory limitations.

    If you find that the tmx module doesn’t meet your specific needs or if you prefer an alternative approach, you can also parse and process TMX files using other XML parsing libraries in Python, such as xml.etree.ElementTree or lxml. These libraries provide XML parsing capabilities that allow you to extract and manipulate data from TMX files.

    See less
    • 0
    • Share
      Share
      • Share on Facebook
      • Share on Twitter
      • Share on LinkedIn
      • Share on WhatsApp
      • Report
  5. Asked: May 19, 2023

    how to disable button clicks via .preventDefault()

    Best Answer
    Ghulam Nabi
    Added an answer on May 19, 2023 at 7:10 am

    The preventDefault() method is used to prevent the default behavior of an event, such as submitting a form or following a link. However, it does not disable the button or make it unclickable. It only prevents the default action associated with the event. If you want to disable the button and make itRead more

    The preventDefault() method is used to prevent the default behavior of an event, such as submitting a form or following a link. However, it does not disable the button or make it unclickable. It only prevents the default action associated with the event.

    If you want to disable the button and make it unclickable, you can use a reactive variable to control the button’s state. Here’s an updated code snippet that demonstrates how to achieve this:

    <template>
      <div>
        <button v-on:click="handleClick" :disabled="isButtonDisabled">warn</button>
      </div>
    </template>
    
    <script>
    import { ref } from 'vue';
    
    export default {
      name: 'App',
      setup() {
        const isButtonDisabled = ref(false);
    
        const handleClick = (event) => {
          event.preventDefault();
          if (!isButtonDisabled.value) {
            // Perform your desired action here
            console.log('Button clicked!');
          }
        };
    
        return {
          isButtonDisabled,
          handleClick,
        };
      },
    };
    </script>
    

    In this example, we use the isButtonDisabled reactive variable to control the disabled attribute of the button. By default, the button is not disabled (isButtonDisabled is false). When the button is clicked, the handleClick function is triggered. We check if the button is not disabled before performing any action. By calling event.preventDefault(), we prevent the default behavior of the click event.

    To disable the button, you can set isButtonDisabled to true in your code when necessary. For example, if you want to disable the button after the first click, you can modify the handleClick function as follows:

    const handleClick = (event) => {
      event.preventDefault();
      if (!isButtonDisabled.value) {
        // Perform your desired action here
        console.log('Button clicked!');
        isButtonDisabled.value = true; // Disable the button
      }
    };
    

    By setting isButtonDisabled.value to true, the button will become disabled, and subsequent clicks will not trigger the action inside the if statement.

    Remember to import the necessary dependencies (ref) and adjust the component name and any other dependencies according to your specific setup.

    See less
    • 0
    • Share
      Share
      • Share on Facebook
      • Share on Twitter
      • Share on LinkedIn
      • Share on WhatsApp
      • Report
  6. Asked: May 19, 2023

    How to create a small python code to get a list of participants of a teams call?

    Best Answer
    Ghulam Nabi
    Added an answer on May 19, 2023 at 7:07 am

    To retrieve the list of participants in an ongoing Microsoft Teams call using Python, you can utilize the Microsoft Graph API with the help of the requests library. Here's a code snippet that demonstrates how to achieve this: import requests # Microsoft Graph API endpoint for retrieving call particiRead more

    To retrieve the list of participants in an ongoing Microsoft Teams call using Python, you can utilize the Microsoft Graph API with the help of the requests library. Here’s a code snippet that demonstrates how to achieve this:

    import requests
    
    # Microsoft Graph API endpoint for retrieving call participants
    call_participants_url = 'https://graph.microsoft.com/v1.0/communications/calls/{call_id}/participants'
    
    # Azure AD application credentials
    client_id = 'your_client_id'
    client_secret = 'your_client_secret'
    tenant_id = 'your_tenant_id'
    
    # Get an access token using client credentials flow
    token_url = f'https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token'
    token_payload = {
        'client_id': client_id,
        'client_secret': client_secret,
        'scope': 'https://graph.microsoft.com/.default',
        'grant_type': 'client_credentials'
    }
    
    token_response = requests.post(token_url, data=token_payload)
    access_token = token_response.json().get('access_token')
    
    # Make a GET request to obtain the list of participants
    call_id = 'your_call_id'
    headers = {'Authorization': f'Bearer {access_token}'}
    participants_response = requests.get(call_participants_url.format(call_id=call_id), headers=headers)
    participants = participants_response.json()
    
    # Process the participant data
    for participant in participants['value']:
        print(participant['displayName'])
    

    Before running the code, make sure you replace the following placeholders with your own values:

    • your_client_id: Your Azure AD application ID (client ID).
    • your_client_secret: Your Azure AD application client secret.
    • your_tenant_id: Your Azure AD tenant ID.
    • your_call_id: The ID of the Teams call you want to retrieve participants for.

    Please note that you need the necessary permissions and valid Azure AD application credentials to access the Microsoft Graph API. Also, ensure that you have the requests library installed (pip install requests) to make HTTP requests

    See less
    • 0
    • Share
      Share
      • Share on Facebook
      • Share on Twitter
      • Share on LinkedIn
      • Share on WhatsApp
      • Report
  7. Asked: May 19, 2023

    undeclared variable in a do-while loop in C

    Best Answer
    Ghulam Nabi
    Added an answer on May 19, 2023 at 7:04 am

    In C, variable declarations should be placed outside the loop in which they are used. In your code, the variable sp is declared inside the do-while loop, making it inaccessible in the condition part of the loop. To fix the error, you need to declare the variable sp before the do-while loop: int sp;Read more

    In C, variable declarations should be placed outside the loop in which they are used. In your code, the variable sp is declared inside the do-while loop, making it inaccessible in the condition part of the loop.

    To fix the error, you need to declare the variable sp before the do-while loop:

    int sp; // Declare the variable before the loop
    
    do
    {
        sp = get_int("Enter the start size of llama population:");
    }
    while (sp >= 9);
    

    By moving the declaration of sp outside the loop, it becomes accessible in both the loop body and the condition part of the loop.

    Now, the code will prompt the user to enter a valid number (greater or equal to 9) until the condition is satisfied.

    Make sure you have the necessary header files included and the get_int function defined or declared correctly before using it in your code.

    See less
    • 0
    • Share
      Share
      • Share on Facebook
      • Share on Twitter
      • Share on LinkedIn
      • Share on WhatsApp
      • Report
  8. Asked: May 19, 2023

    Cypress use clock between each test without visit again

    Best Answer
    Ghulam Nabi
    Added an answer on May 19, 2023 at 6:59 am

    It seems that the issue lies in the way Cypress handles the setInterval function and the clock. Currently, Cypress's cy.tick() function is not designed to advance the clock for intervals set using setInterval. To work around this limitation, you can use the cy.wait() command instead of cy.tick() toRead more

    It seems that the issue lies in the way Cypress handles the setInterval function and the clock. Currently, Cypress’s cy.tick() function is not designed to advance the clock for intervals set using setInterval.

    To work around this limitation, you can use the cy.wait() command instead of cy.tick() to advance the clock. Here’s an updated example of how you can modify your tests:

    describe('test clock', () => {
      beforeEach(() => {
        cy.clock(); // Initialize the clock
        cy.visit('http://localhost:3000/#/index/dashboardview2');
      });
    
      it('test1', () => {
        cy.get('[data-test="number"]').should('have.text', '0');
        cy.wait(1000); // Advance the clock by 1 second using cy.wait()
        cy.get('[data-test="number"]').should('have.text', '1');
      });
    
      it('test2', () => {
        cy.get('[data-test="number"]').should('have.text', '0');
        cy.wait(2000); // Advance the clock by 2 seconds using cy.wait()
        cy.get('[data-test="number"]').should('have.text', '2');
      });
    });
    

    By replacing cy.tick() with cy.wait(), you can manually control the clock advancement and verify the expected behavior in your component.

    Please give this approach a try and let me know if it resolves the issue for you.

    See less
    • 0
    • Share
      Share
      • Share on Facebook
      • Share on Twitter
      • Share on LinkedIn
      • Share on WhatsApp
      • Report
  9. Asked: May 18, 2023

    How to exclude @Bean from library configuration

    Best Answer
    Ghulam Nabi
    Added an answer on May 18, 2023 at 11:23 am

    @Configuration @Import({ClientConfig.class}) public class ValidatorsConfiguration { @Bean @Conditional(ExcludeBeanCondition.class) public Parser excludedParser() { // Return a dummy instance or null if you want to exclude the bean return null; } // Other beans and configuration... } In the example aRead more

    @Configuration
    @Import({ClientConfig.class})
    public class ValidatorsConfiguration {
        
        @Bean
        @Conditional(ExcludeBeanCondition.class)
        public Parser excludedParser() {
            // Return a dummy instance or null if you want to exclude the bean
            return null;
        }
    
        // Other beans and configuration...
    }
    

    In the example above, a new Parser bean called excludedParser() is defined. The @Conditional(ExcludeBeanCondition.class) annotation is used to conditionally include or exclude this bean based on the implementation of the ExcludeBeanCondition class.

    You need to create the ExcludeBeanCondition class implementing the Condition interface. Here’s an example implementation that excludes the bean based on a specific condition:

    public class ExcludeBeanCondition implements Condition {
    
        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
            // Implement your custom logic here to determine if the bean should be excluded
            // Return true to exclude the bean, false to include it
            // You can access environment variables, properties, etc., using the ConditionContext
            
            // Example: Exclude the bean if a specific property is set
            String excludeProperty = context.getEnvironment().getProperty("exclude.bean");
            return "true".equalsIgnoreCase(excludeProperty);
        }
    }
    

    In the ExcludeBeanCondition class, you can define your custom logic to determine if the bean should be excluded. In this example, the bean will be excluded if the property exclude.bean is set to "true".

    Remember to adjust the logic in ExcludeBeanCondition according to your specific conditions for excluding beans.

    See less
    • 0
    • Share
      Share
      • Share on Facebook
      • Share on Twitter
      • Share on LinkedIn
      • Share on WhatsApp
      • Report
  10. Asked: May 18, 2023

    How can I use another df to calculate a new variable in my df, using time intervals?

    Best Answer
    Ghulam Nabi
    Added an answer on May 18, 2023 at 11:18 am

    To calculate the new variable in your dataframe based on time intervals and information from another dataframe, you can use a combination of filtering and aggregation functions. Here's an example of how you can approach this task: library(dplyr) # Assuming your dataframes are named 'exposition' andRead more

    To calculate the new variable in your dataframe based on time intervals and information from another dataframe, you can use a combination of filtering and aggregation functions. Here’s an example of how you can approach this task:

    library(dplyr)
    
    # Assuming your dataframes are named 'exposition' and 'pregnancy_interval'
    
    # Initialize a new column for the pollution dataframe
    pollution$sum <- 0
    
    # Loop over each row in the exposition dataframe
    for (i in 1:nrow(exposition)) {
      # Get the code_muni and time interval for the current row in exposition
      code_muni <- exposition$code_muni[i]
      dt_concep <- exposition$dt_concep[i]
      data_nasc <- exposition$data_nasc[i]
      
      # Filter the pollution dataframe based on the code_muni and time interval
      filtered_data <- pollution %>%
        filter(code_muni == code_muni,
               date >= dt_concep,
               date < data_nasc)
      
      # Calculate the sum for the specified time interval
      sum_value <- sum(filtered_data$neg_to_7)
      
      # Update the 'sum' column in the pollution dataframe for the matching rows
      pollution$sum[code_muni == code_muni &
                    pollution$date >= dt_concep &
                    pollution$date < data_nasc] <- sum_value
    }
    

    This code loops over each row in the exposition dataframe and performs the following steps:

    1. Extracts the code_muni, dt_concep, and data_nasc values from the current row.
    2. Filters the pollution dataframe based on the code_muni and the time interval.
    3. Calculates the sum of the neg_to_7 values for the filtered data.
    4. Updates the sum column in the pollution dataframe for the matching rows.

    Note that this approach can be time-consuming if your dataframes are large. Consider optimizing it if needed, such as by using vectorized operations or parallel processing, depending on the size and complexity of your data.

    See less
    • 0
    • Share
      Share
      • Share on Facebook
      • Share on Twitter
      • Share on LinkedIn
      • Share on WhatsApp
      • Report
1 2 3 … 16

Sidebar

Ask A Question
  • Popular
  • Answers
  • Ghulam Nabi

    Why are the British confused about us calling bread rolls ...

    • 5 Answers
  • Jerry

    Add file to native target programmatically via tuist/XcodeProj

    • 4 Answers
  • Ghulam Nabi

    Is this statement, “i see him last night” can be ...

    • 4 Answers
  • Ghulam Nabi
    Ghulam Nabi added an answer Improving the launch time of your Flutter Firebase app involves… May 25, 2023 at 12:08 pm
  • Ghulam Nabi
    Ghulam Nabi added an answer Currently, as of my knowledge cutoff in September 2021, the… May 25, 2023 at 12:05 pm
  • Ghulam Nabi
    Ghulam Nabi added an answer When using a GitHub Application token for authentication in your… May 25, 2023 at 12:03 pm

Trending Tags

c++ cypress flutter git java javascript python selenium testng webdriver

Top Members

Robert

Robert

  • 3 Questions
  • 1k Points
Luci

Luci

  • 5 Questions
  • 1k Points
Kevin O Brien

Kevin O Brien

  • 2 Questions
  • 1k Points

Explore

  • Home
  • Add group
  • Groups page
  • Communities
  • Questions
    • New Questions
    • Trending Questions
    • Must read Questions
    • Hot Questions
  • Polls
  • Tags
  • Badges
  • Users
  • Help

Footer

Softans

Softans is a social questions & Answers Engine which will help you establish your community and connect with other people.

About Us

  • Blog
  • Jobs
  • About Us
  • Meet The Team
  • Contact Us

Legal Stuff

Help

Follow

© 2021 Softans. All Rights Reserved
With Love by Softans.