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