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