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