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