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