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