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