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