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