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