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