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