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