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