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