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