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