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