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