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