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