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