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