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