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