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