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