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