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