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