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